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 tracking active |
| Phased planning in use |
| Project explored/planned |
| or | AI context exists |
| Correction rules present |
| or | Has dependencies |
| or | Has test infrastructure |
Step 2: Git State (if git repo)
bash
git status --short # Uncommitted changes?
git log --oneline -3 # Recent commit messages?
Step 3: Assess Stage and Recommend
Project Stages:
| Stage | Signs | Recommend |
|---|
| New Project | No CLAUDE.md, no phases | or |
| Active Development | SESSION.md or phases exist | , developer agents |
| Maintenance Mode | Docs exist, no SESSION.md | for new work, for audits |
| Mid-Session | Uncommitted changes + SESSION.md | Continue current work, 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 to resume")
- What's available but not in use (e.g., "No tests yet - available")
Example:
Project Analysis
✓
- AI context configured
✓
- Session tracking active (Phase 2 in progress)
✓
- 3 correction rules
○ No test files detected
Recommendations:
- Run to resume Phase 2 work
- Use agent when ready to commit
- Consider 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 |
|---|
| Analyze project, recommend tools |
| Start with a vague idea |
| Plan a new project |
| Plan a specific feature |
| End work session |
| Resume from last session |
| Create project docs |
| Update docs after changes |
| Preserve context before clearing |
| Capture learnings → rules, skills, memory |
| Prepare for deployment |
Agents (Claude uses these automatically)
| Agent | What it does |
|---|
| Writes commit messages |
| Reviews code quality |
| Investigates bugs |
| Runs/writes tests |
| Checks dist matches source |
| Creates/updates docs |
| Coordinates multi-step work |
Skills (background knowledge)
| Skill | What it provides |
|---|
| Phase-based planning templates |
project-session-management
| SESSION.md patterns |
| Doc maintenance commands |
| Multi-agent debugging |
| AI-readability audits |
| 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 | |
| Plan a new project | |
| Plan a specific feature | |
| End a work session | |
| Resume after a break | |
| Create/update docs | , |
| Debug something stubborn | skill |
| Review code quality | agent |
| Run tests with TDD | agent |
| Prepare a git commit | agent |
| Verify build output | agent |
| Check docs are AI-readable | agent |
| Validate workflows work | agent |
| Check session handoff quality | agent |
Component Skills
Project Lifecycle (project-workflow)
Nine integrated commands for the complete project lifecycle:
| Command | Purpose |
|---|
| Brainstorm and validate project concepts |
| Generate phased implementation plan |
| Plan a specific feature addition |
| Create initial project documentation |
| Update docs after changes |
| End session with git checkpoint |
| Resume from SESSION.md |
| Review progress and plan next steps |
| 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 |
|---|
| Generate meaningful commit messages |
| Security, quality, architecture review |
| Systematic bug investigation |
| TDD workflows, test creation |
| Verify dist/ matches source |
| Create/update project docs |
| 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 |
|---|
| Check if docs are AI-readable (score 0-100) |
| Verify documented processes work (score 0-100) |
| Validate session continuity quality (score 0-100) |
Invoke:
Skill(skill: "project-health")
Documentation Lifecycle (docs-workflow)
Four commands for documentation management:
| Command | Purpose |
|---|
| Quick doc lookup |
| Create initial docs |
| Update after changes |
| 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:
bash
# Bad: commits as save points
git commit -m "WIP"
git commit -m "more changes"
# Good: commits as progress markers
git commit -m "Complete Phase 1: Database schema and migrations"
git commit -m "Phase 2 partial: Auth middleware working, UI pending"
When resuming via
, 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 | | (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" | |
| "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. 🥄