Context Mate
A toolkit that works with Claude Code's natural flow. Use what helps, ignore what doesn't.
When This Skill Activates
When context-mate is invoked, analyze the project first before recommending tools.
Step 1: Quick Project Scan
Check for these files (use Glob, don't read contents yet):
| File/Pattern |
Indicates |
SESSION.md |
Session tracking active |
IMPLEMENTATION_PHASES.md |
Phased planning in use |
PROJECT_BRIEF.md |
Project explored/planned |
CLAUDE.md or .claude/ |
AI context exists |
.claude/rules/ |
Correction rules present |
package.json or requirements.txt |
Has dependencies |
tests/ or *.test.* |
Has test infrastructure |
Step 2: Git State (if git repo)
git status --short
git log --oneline -3
Step 3: Assess Stage and Recommend
Project Stages:
| Stage |
Signs |
Recommend |
| New Project |
No CLAUDE.md, no phases |
/explore-idea or /plan-project |
| Active Development |
SESSION.md or phases exist |
/continue-session, developer agents |
| Maintenance Mode |
Docs exist, no SESSION.md |
/plan-feature for new work, project-health for audits |
| Mid-Session |
Uncommitted changes + SESSION.md |
Continue current work, /wrap-session when done |
Step 4: Brief Output
Tell the user:
- What's already set up (e.g., "You have SESSION.md and phases - mid-project")
- What would help now (e.g., "Run
/continue-session to resume")
- What's available but not in use (e.g., "No tests yet -
test-runner available")
Example:
Project Analysis
✓ CLAUDE.md - AI context configured
✓ SESSION.md - Session tracking active (Phase 2 in progress)
✓ .claude/rules/ - 3 correction rules
○ No test files detected
Recommendations:
- Run
/continue-session to resume Phase 2 work
- Use
commit-helper agent when ready to commit
- Consider
test-runner agent when adding tests
Keep it under 10 lines. Don't overwhelm - just highlight what's relevant.
The name has a double meaning:
- Your friendly context companion (the toolkit)
- "It's all about the context, maaate!" (the philosophy)
This isn't "The Correct Way To Do Things" - these tools exist because context windows are real constraints, not because we're dictating methodology.
Quick Reference
Slash Commands (type these)
| Command |
What it does |
/context-mate |
Analyze project, recommend tools |
/explore-idea |
Start with a vague idea |
/plan-project |
Plan a new project |
/plan-feature |
Plan a specific feature |
/wrap-session |
End work session |
/continue-session |
Resume from last session |
/docs-init |
Create project docs |
/docs-update |
Update docs after changes |
/brief |
Preserve context before clearing |
/reflect |
Capture learnings → rules, skills, memory |
/release |
Prepare for deployment |
Agents (Claude uses these automatically)
| Agent |
What it does |
commit-helper |
Writes commit messages |
code-reviewer |
Reviews code quality |
debugger |
Investigates bugs |
test-runner |
Runs/writes tests |
build-verifier |
Checks dist matches source |
documentation-expert |
Creates/updates docs |
orchestrator |
Coordinates multi-step work |
Skills (background knowledge)
| Skill |
What it provides |
project-planning |
Phase-based planning templates |
project-session-management |
SESSION.md patterns |
docs-workflow |
Doc maintenance commands |
deep-debug |
Multi-agent debugging |
project-health |
AI-readability audits |
developer-toolbox |
The 7 agents above |
The Toolkit at a Glance
┌─────────────────────────────────────────────────────────────┐
│ PROJECT LIFECYCLE │
├─────────────────────────────────────────────────────────────┤
│ /explore-idea → /plan-project → [work] → /wrap-session │
│ ↓ ↓ ↓ ↓ │
│ PROJECT_BRIEF PHASES.md SESSION.md git checkpoint │
│ ↓ │
│ /continue-session │
│ ↓ │
│ [resume work] │
│ ↓ │
│ /reflect → /release │
└─────────────────────────────────────────────────────────────┘
When To Use What
| You want to... |
Use this |
| Explore a vague idea |
/explore-idea |
| Plan a new project |
/plan-project |
| Plan a specific feature |
/plan-feature |
| End a work session |
/wrap-session |
| Resume after a break |
/continue-session |
| Create/update docs |
/docs-init, /docs-update |
| Debug something stubborn |
deep-debug skill |
| Review code quality |
code-reviewer agent |
| Run tests with TDD |
test-runner agent |
| Prepare a git commit |
commit-helper agent |
| Verify build output |
build-verifier agent |
| Check docs are AI-readable |
context-auditor agent |
| Validate workflows work |
workflow-validator agent |
| Check session handoff quality |
handoff-checker agent |
Component Skills
Project Lifecycle (project-workflow)
Nine integrated commands for the complete project lifecycle:
| Command |
Purpose |
/explore-idea |
Brainstorm and validate project concepts |
/plan-project |
Generate phased implementation plan |
/plan-feature |
Plan a specific feature addition |
/docs-init |
Create initial project documentation |
/docs-update |
Update docs after changes |
/wrap-session |
End session with git checkpoint |
/continue-session |
Resume from SESSION.md |
/reflect |
Review progress and plan next steps |
/release |
Prepare for deployment/release |
Invoke: Skill(skill: "project-workflow")
Session Management (project-session-management)
Track progress across context windows using SESSION.md with git checkpoints.
- Converts IMPLEMENTATION_PHASES.md into actionable tracking
- Creates semantic git commits as recovery points
- Documents concrete next actions for resumption
- Prevents context loss between sessions
Invoke: Skill(skill: "project-session-management")
Developer Agents (developer-toolbox)
Seven specialized agents for common development tasks:
| Agent |
Use For |
commit-helper |
Generate meaningful commit messages |
code-reviewer |
Security, quality, architecture review |
debugger |
Systematic bug investigation |
test-runner |
TDD workflows, test creation |
build-verifier |
Verify dist/ matches source |
documentation-expert |
Create/update project docs |
orchestrator |
Coordinate multi-step projects |
Invoke: Skill(skill: "developer-toolbox")
Deep Debugging (deep-debug)
Multi-agent investigation for stubborn bugs that resist normal debugging.
- Spawns parallel investigation agents
- Cross-references findings
- Handles browser/runtime issues
- Best when going in circles on a bug
Invoke: Skill(skill: "deep-debug")
Quality Auditing (project-health)
Three agents for AI-readability and workflow quality:
| Agent |
Purpose |
context-auditor |
Check if docs are AI-readable (score 0-100) |
workflow-validator |
Verify documented processes work (score 0-100) |
handoff-checker |
Validate session continuity quality (score 0-100) |
Invoke: Skill(skill: "project-health")
Documentation Lifecycle (docs-workflow)
Four commands for documentation management:
| Command |
Purpose |
/docs |
Quick doc lookup |
/docs-init |
Create initial docs |
/docs-update |
Update after changes |
/docs-claude |
Generate AI-optimized CLAUDE.md |
Invoke: Skill(skill: "docs-workflow")
Core Concepts
Sessions ≠ Phases
Sessions are context windows (2-4 hours of work before context fills up).
Phases are work units (logical groupings like "Phase 1: Database Setup").
A phase might span multiple sessions. A session might touch multiple phases. They're independent concepts.
Checkpointed Progress
Git commits serve as semantic checkpoints, not just version control:
git commit -m "WIP"
git commit -m "more changes"
git commit -m "Complete Phase 1: Database schema and migrations"
git commit -m "Phase 2 partial: Auth middleware working, UI pending"
When resuming via /continue-session, these commits tell the story of where you are.
Progressive Disclosure
Skills load incrementally to preserve context:
- Metadata (~50 tokens) - Always in context, triggers skill loading
- SKILL.md body (<5k words) - Loaded when skill activates
- Bundled resources - Loaded as needed (templates, references, scripts)
This means a 50-skill toolkit only costs ~2,500 tokens until you actually use something.
Skills Teach, Rules Correct
Two complementary knowledge systems:
|
Skills |
Rules |
| Location |
~/.claude/skills/ |
.claude/rules/ (project) |
| Content |
Rich bundles |
Single markdown files |
| Purpose |
Teach how to use X |
Correct outdated patterns |
| Example |
How to set up Tailwind v4 |
Fix v3 syntax Claude might suggest |
Rules are project-portable - they travel with the repo so any Claude instance gets the corrections.
Sub-agents for Isolation
Heavy tasks (code review, debugging, testing) run in sub-agents to:
- Keep verbose output out of main context
- Allow parallel execution
- Provide specialized tool access
- Return concise summaries
Getting Started
New Project
/explore-idea # Optional: clarify what you're building
/plan-project # Generate phased plan
# Work on Phase 1...
/wrap-session # End with checkpoint
Resuming Work
/continue-session # Reads SESSION.md, suggests next steps
# Continue working...
/wrap-session # Checkpoint again
Adding a Feature
/plan-feature # Plan the specific feature
# Implement...
/wrap-session # Checkpoint
Debugging Session
# If normal debugging isn't working:
Skill(skill: "deep-debug")
# Spawns investigation agents
The Philosophy
Context windows are real. They fill up. Work gets lost. Sessions end.
These tools don't fight that - they work with it:
- SESSION.md captures state for next session
- Git checkpoints create recovery points
- Sub-agents keep heavy work isolated
- Progressive disclosure preserves context budget
Use what helps. Ignore what doesn't.
This is the knifey-spooney school of project management:
| Traditional PM |
Context Mate |
| "Follow the methodology" |
"She'll be right" |
| "Update the Gantt chart" |
/wrap-session |
| "Consult the RACI matrix" |
"Oi Claude, what next?" |
No ceremonies. No standups with your AI. No burndown charts.
If Homer Simpson can't figure it out in 30 seconds, it's too complicated.
It's all about the context, maaate. 🥄
