Claude-skill-registry context-mate

install

source · Clone the upstream repo

git clone https://github.com/majiayu000/claude-skill-registry

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/majiayu000/claude-skill-registry "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/data/context-mate" ~/.claude/skills/majiayu000-claude-skill-registry-context-mate && rm -rf "$T"

manifest: skills/data/context-mate/SKILL.md

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            # 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	`/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:

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

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