superpowers-reference

Reference: The Superpowers Pipeline

The full development workflow:

/brainstorm  ->  Design document (user validates each section)
     |
/write-plan  ->  Implementation plan (bite-sized TDD tasks)
     |
/execute-plan  ->  Subagent-driven development (implement -> spec-review -> quality-review per task)
     |
/verify  ->  Fresh evidence that everything works
     |
/finish  ->  Merge / PR / Keep / Discard

At any point, if bugs arise: /debug (4-phase systematic debugging).

Priority order when multiple modes could apply:

1. •Process modes first (/brainstorm, /debug) -- determine HOW to approach the task
2. •Implementation modes second (/write-plan, /execute-plan) -- guide execution
3. •Completion modes last (/verify, /finish) -- close out work

Reference: Mode Tool

The mode tool allows programmatic mode transitions. Use mode(operation="set", name="write-plan") to request a mode change. The first request will be blocked with a reminder — call again to confirm. This is useful when agents need to request transitions during automated workflows.

Reference: Modes

Reference: Agents

Delegation rules:

• •Brainstorm and Write-Plan: YOU own the conversation. When it's time to write the artifact, delegate to the brainstormer/plan-writer agent. The back-and-forth with the user is what makes these phases effective. The agent writes the document after you've validated everything.
• •Execute-Plan: YOU delegate everything. You are the orchestrator. Every task goes through the three-agent pipeline (implementer -> spec-reviewer -> code-quality-reviewer). You never write code in this mode.
• •Debug, Verify, Finish: YOU do the work directly. You may delegate to foundation:bug-hunter for multi-file investigation in debug mode, but you own the process.

Why fresh subagents per task:

• •Clean context — No pollution from previous work
• •Focused attention — Single task, single responsibility
• •Quality gates — Review checkpoints catch issues early
• •Parallel safety — Subagents don't interfere with each other

Reference: Recipes

Execute these workflows using the recipes tool:

Reference: Anti-Rationalization Table

Reference: Key Rules

1. •Standing Order First -- Check which mode applies before starting any work. Suggest it even if you're only 1% sure.
2. •Own Design Conversations, Delegate Artifacts -- You brainstorm and write plans through conversation. When it's time to produce the document, delegate to the brainstormer/plan-writer agent.
3. •Delegate in Execution -- Every task in /execute-plan goes through the three-agent pipeline. No exceptions.
4. •TDD Always -- No production code without failing test first.
5. •Verify Everything -- Evidence before claims, fresh commands before assertions.
6. •Systematic Debugging -- Root cause before fixes, 4 phases in order.
7. •Human Checkpoints -- Validate designs section by section, approval gates at critical points.
8. •Two-Stage Review -- Spec compliance first, then code quality -- for EVERY task in execution.

Reference: Skills

Load these for reference using the skills tool:

Philosophy Reference

For deep understanding of the principles, see:

• •superpowers:context/philosophy.md -- Core principles, anti-patterns, and the two-stage review pattern