A design-first, TDD-enforced development methodology for coding agents, skills that auto-activate across Claude Code, Cursor, Codex, and more.
Without a methodology, every coding session starts from scratch and quality gates exist only when you remember to apply them. Superpowers is not a plugin collection. It is a structured development methodology implemented as composable skills: design and clarification before planning, structured planning before implementation, test-driven RED-GREEN-REFACTOR execution, git worktree isolation for parallel subagent work, and mandatory code review gates. Skills auto-activate based on development stage across Claude Code, Cursor, Codex, OpenCode, and GitHub Copilot CLI. No manual invocation required.
Steps
The fastest path is claude plugin install. If Superpowers is not yet in your marketplace, clone the repo and copy the skills folder into `~/.claude/skills/`. If you only need one skill immediately, copy its SKILL.md into your skills folder and add the rest later. Always restart Claude Code after install.
Before writing code for any task spanning more than one file or thirty minutes, run writing-plans. It interviews you about scope, dependencies, and risks, then produces a structured plan with atomic tasks and phase gates. Plans produced by writing-plans are the format executing-plans and gsd:execute-phase expect.
Hand the plan file to executing-plans. It reads the current phase, works through its tasks with explicit verification gates, and will not advance until the gate passes. This is what makes long builds survivable. You cannot drift into Phase 4 while Phase 2 is half-done.
Before opening a pull request, run finishing-a-development-branch. It runs a pre-PR checklist: tests pass, types clean, unused imports removed, CLAUDE.md current, changelog updated, PR description drafted. Three minutes. Catches the things that turn a review into a back-and-forth.
code-review runs a structured review pass on a file or diff. It checks for logic errors, security issues, and anti-patterns in a consistent format. systematic-debugging refuses to jump to fixes before identifying the root cause. Both fire automatically at the right moments via the CLAUDE.md rule set. But you can also invoke them manually any time.
How do you know it worked?
If something looks off
Skills & Commands Reference
Superpowers skills are invoked by the agent automatically based on context. You don't call them directly. Each skill is a mandatory workflow with specific steps. Knowing what each one enforces helps you understand why the agent behaves the way it does.
| Command / Skill | What it does | When to use it |
|---|---|---|
writing-plansbasic | Enforces research → spec → task breakdown → appendix before any code is written | Any feature, fix, or change that touches more than one file, this fires first |
executing-plansbasic | Implements from an approved plan, one task at a time, with verification between tasks | After a plan is written and approved, the implementation gate |
finishing-a-development-branchbasic | Pre-merge checklist: tests pass, types clean, docs updated, PR description written | Before merging any branch, enforces quality gates before the code lands |
requesting-code-reviewbasic | Structures a code review request with context, scope, and specific questions | When you want a focused review rather than a general pass |
receiving-code-reviewbasic | Processes review feedback systematically, categorizes, addresses, and confirms resolution | After receiving review comments, prevents cherry-picking easy feedback |
systematic-debuggingbasic | Root-cause analysis before fixing: hypothesis → evidence → fix → verify. No blind changes | Any bug where the cause is not immediately obvious, fires before any edit is made |
test-driven-developmentadvanced | Red-green-refactor loop: write failing test → make it pass → refactor → repeat | New functionality where correctness is critical and the interface is known upfront |
using-git-worktreesadvanced | Creates isolated worktrees for parallel work, prevents branch contamination | Multiple features or fixes running concurrently, each gets its own worktree |
dispatching-parallel-agentsadvanced | Launches multiple specialized agents simultaneously on independent subtasks | Large tasks with clearly separable pieces, research + implementation + testing in parallel |
subagent-driven-developmentadvanced | Delegates discrete subtasks to isolated subagents with clean context | Long sessions approaching context limits, or subtasks that need fresh context to execute cleanly |
verification-before-completionbasic | Blocks task completion until all success criteria are verified with actual tool output, not assertions | Fires before any task is marked done. 'Should work' is not verification |
brainstormingbasic | Structured exploration of approaches before committing, surfaces trade-offs and alternatives | Before entering plan mode on any non-trivial task |
writing-skillsadvanced | Guides creation of a new Superpowers skill following the spec, eval, and test format | You want to capture a workflow you've validated into a reusable skill |