Command Reference

You've got a feature request and a blank page. This command turns "we need OAuth" into a structured plan that actually tells you what to build—researched, reviewed, and ready to execute.

Arguments

[feature description, bug report, or improvement idea]

Workflow

1. Repository Research (Parallel) - Launch three agents simultaneously:
   • repo-research-analyst - Project patterns
   • best-practices-researcher - Industry standards
   • framework-docs-researcher - Framework documentation
2. SpecFlow Analysis - Run spec-flow-analyzer for user flows
3. Choose Detail Level:
   • MINIMAL - Simple bugs/small improvements
   • MORE - Standard features
   • A LOT - Major features with phases
4. Write Plan - Save as plans/<issue_title>.md
5. Review - Call /plan_review for multi-agent feedback

/plan Add OAuth integration for third-party auth
/plan Fix N+1 query in user dashboard

Twelve specialized reviewers examine your PR in parallel—security, performance, architecture, patterns. It's like code review by committee, except the committee finishes in two minutes instead of two days.

Arguments

[PR number, GitHub URL, branch name, or "latest"]

Workflow

1. Setup - Detect review target, optionally use git-worktree for isolation
2. Launch 12 Parallel Review Agents:
   • kieran-rails-reviewer, dhh-rails-reviewer
   • security-sentinel, performance-oracle
   • architecture-strategist, data-integrity-guardian
   • pattern-recognition-specialist, git-history-analyzer
   • And more...
3. Ultra-Thinking Analysis - Stakeholder perspectives, scenario exploration
4. Simplification Review - Run code-simplicity-reviewer
5. Synthesize Findings - Categorize by severity (P1/P2/P3)
6. Create Todo Files - Using file-todos skill for all findings

/review 42
/review https://github.com/owner/repo/pull/42
/review feature-branch-name
/review latest

Point this at a plan file and watch it execute—reading requirements, setting up environment, running tests, creating commits, opening PRs. It's the "just build the thing" button you wish you always had.

Arguments

[plan file, specification, or todo file path]

Phases

1. Quick Start
   • Read plan & clarify requirements
   • Setup environment (live or worktree)
   • Create TodoWrite task list
2. Execute
   • Task execution loop with progress tracking
   • Follow existing patterns
   • Test continuously
   • Figma sync if applicable
3. Quality Check
   • Run test suite
   • Run linting
   • Optional reviewer agents for complex changes
4. Ship It
   • Create commit with conventional format
   • Create pull request
   • Notify with summary

/work plans/user-authentication.md
/work todos/042-ready-p1-performance-issue.md

Just fixed a gnarly bug? This captures the solution before you forget it. Seven agents analyze what you did, why it worked, and how to prevent it next time. Each documented solution compounds your team's knowledge.

Arguments

[optional: brief context about the fix]

Workflow

1. Preconditions - Verify problem is solved and verified working
2. Launch seven parallel subagents:
   • Context Analyzer - Extract YAML frontmatter skeleton
   • Solution Extractor - Identify root cause and solution
   • Related Docs Finder - Find cross-references
   • Prevention Strategist - Develop prevention strategies
   • Category Classifier - Determine docs category
   • Documentation Writer - Create the file
   • Optional Specialized Agent - Based on problem type
3. Create Documentation - File in docs/solutions/[category]/

Auto-Triggers

Phrases: "that worked", "it's fixed", "working now", "problem solved"

/compound
/compound N+1 query optimization

Turn your git history into a changelog people actually want to read. Breaking changes at the top, fun facts at the bottom, everything organized by what matters to your users.

Arguments

[optional: daily|weekly, or time period in days]

Output Sections

• Breaking Changes (top priority)
• New Features
• Bug Fixes
• Other Improvements
• Shoutouts
• Fun Fact

/changelog daily
/changelog weekly
/changelog 7

Need a new skill? This walks you through creating one that actually works—proper frontmatter, clear documentation, all the conventions baked in. Think of it as scaffolding for skills.

Arguments

[skill description or requirements]

/create-agent-skill PDF processing for document analysis
/create-agent-skill Web scraping with error handling

Same idea, but for commands instead of skills. Tell it what workflow you're tired of doing manually, and it generates a proper slash command with all the right patterns.

Arguments

[command purpose and requirements]

/generate_command Security audit for codebase
/generate_command Automated performance testing

Skills drift—APIs change, URLs break, parameters get renamed. When a skill stops working, this figures out what's wrong and fixes the documentation. You approve the changes before anything commits.

Arguments

[optional: specific issue to fix]

Approval Options

1. Apply and commit
2. Apply without commit
3. Revise changes
4. Cancel

/heal-skill API endpoint URL changed
/heal-skill parameter validation error

Before you execute a plan, have three reviewers tear it apart—Rails conventions, best practices, simplicity. Better to find the problems in the plan than in production.

Arguments

[plan file path or plan content]

Review Agents

• dhh-rails-reviewer - Rails conventions
• kieran-rails-reviewer - Rails best practices
• code-simplicity-reviewer - Simplicity and clarity

/plan_review plans/user-authentication.md

Something broken? This collects all the context—what broke, what you expected, error messages, environment—and files a proper bug report. No more "it doesn't work" issues.

Arguments

[optional: brief description of the bug]

Information Collected

• Bug category (Agent/Command/Skill/MCP/Installation)
• Specific component name
• Actual vs expected behavior
• Steps to reproduce
• Error messages
• Environment info (auto-gathered)

/report-bug Agent not working
/report-bug Command failing with timeout

Give it a GitHub issue number and it tries to actually reproduce the bug—reading the issue, analyzing code paths, iterating until it finds the root cause. Then it posts findings back to the issue.

Arguments

[GitHub issue number]

Investigation Process

1. Read GitHub issue details
2. Launch parallel investigation agents
3. Analyze code for failure points
4. Iterate until root cause found
5. Post findings to GitHub issue

/reproduce-bug 142

Got a pile of code review findings or security audit results? This turns them into actionable todos—one at a time, you decide: create the todo, skip it, or modify and re-present.

Arguments

[findings list or source type]

User Decisions

• "yes" - Create/update todo file, change status to ready
• "next" - Skip and delete from todos
• "custom" - Modify and re-present

/triage code-review-findings.txt
/triage security-audit-results

All those TODO comments scattered through your codebase? This finds them, builds a dependency graph, and spawns parallel agents to resolve them all at once. Clears the backlog in minutes.

Arguments

[optional: specific TODO pattern or file]

Process

1. Analyze TODO comments from codebase
2. Create dependency graph (mermaid diagram)
3. Spawn parallel pr-comment-resolver agents
4. Commit and push after completion

/resolve_parallel
/resolve_parallel authentication
/resolve_parallel src/auth/

Same deal, but for PR review comments. Fetch unresolved threads, spawn parallel resolver agents, commit the fixes, and mark threads as resolved. Your reviewers will wonder how you're so fast.

Arguments

[optional: PR number or current PR]

Process

1. Get all unresolved PR comments
2. Create TodoWrite list
3. Launch parallel pr-comment-resolver agents
4. Commit, resolve threads, and push

/resolve_pr_parallel
/resolve_pr_parallel 123

Those todo files in your /todos directory? Point this at them and watch parallel agents knock them out—analyzing dependencies, executing in the right order, marking resolved as they finish.

Arguments

[optional: specific todo ID or pattern]

Process

1. Get unresolved TODOs from /todos/*.md
2. Analyze dependencies
3. Spawn parallel agents
4. Commit, mark as resolved, push

/resolve_todo_parallel
/resolve_todo_parallel 042
/resolve_todo_parallel p1

Your project initialization command. What exactly it does depends on your project setup—think of it as the "get everything ready" button before you start coding.

/prime