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):

Step 2: Git State (if git repo)

git status --short            # Uncommitted changes?
git log --oneline -3          # Recent commit messages?

Step 3: Assess Stage and Recommend

Project Stages:

Step 4: Brief Output

Tell the user:

1. •What's already set up (e.g., "You have SESSION.md and phases - mid-project")
2. •What would help now (e.g., "Run /continue-session to resume")
3. •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:

1. •Your friendly context companion (the toolkit)
2. •"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)

Agents (Claude uses these automatically)

Skills (background knowledge)

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

Component Skills

Project Lifecycle (project-workflow)

Nine integrated commands for the complete project lifecycle:

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:

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:

Invoke: Skill(skill: "project-health")

Documentation Lifecycle (docs-workflow)

Four commands for documentation management:

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:

# 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 /continue-session, these commits tell the story of where you are.

Progressive Disclosure

Skills load incrementally to preserve context:

1. •Metadata (~50 tokens) - Always in context, triggers skill loading
2. •SKILL.md body (<5k words) - Loaded when skill activates
3. •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:

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:

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. 🥄