Superpowers is a free, open-source plugin for Claude Code by Jesse Vincent and the team at Prime Radiant. It ships a set of structured skills, markdown files holding instructions, checklists and process rules, that Claude reads before it takes any action. The effect is that it plans, tests and verifies first instead of writing code the moment you ask.
If you've used Claude Code for more than a week, you know why that matters. You ask it to build something, and it immediately starts writing code. No questions, no plan, no hesitation. It feels fast. It feels productive.
Until you're three files deep and realise it solved the wrong problem.
That immediacy is the source of most AI-coding headaches: missed requirements, skipped tests, massive diffs that are impossible to review, and features that drift subtly from what you actually wanted. Superpowers exists to fix exactly this.
What it actually does
The idea is simple: enforce a complete development methodology. Not a checklist you can skip, but an opinionated workflow that mirrors how experienced engineers actually work. Claude doesn't touch code until the problem is genuinely understood and a plan is in place.
If you want to write a skill of your own, the same principles apply.
Three principles drive everything:
Clarify before coding. Claude must fully understand what you're building before writing a single line. Requirements gaps are caught in conversation, not in debugging sessions.
Red/Green TDD: no exceptions. Tests are written first and must demonstrably fail before any implementation code exists. If Claude writes implementation code before tests, the skill instructs it to delete that code and start over.
YAGNI. Build the simplest thing that works. Complexity is deferred until it's actually needed.
The result: sessions that feel less like babysitting and more like pairing with a disciplined engineer.
The workflow in practice
Once installed, Superpowers routes every task through a structured sequence. A master skill called using-superpowers activates automatically at session start and acts as a dispatcher, it reads your request, determines which skills apply, and activates them in order. You don't invoke phases manually.
Here's what that looks like. You describe something you want to build:
"I need user authentication for my Express app."
Instead of generating code, Claude activates its brainstorming skill. It asks targeted questions: OAuth or passwords? Session-based or JWT? Rate limiting? Password complexity rules? It refines your rough idea into a solid design document, and waits for your explicit approval before moving on.
After approval, it creates an isolated git worktree, generates a granular implementation plan with checkboxes, and then dispatches subagents to execute that plan, one writing code per task, another reviewing it, a third checking it against the original spec. When everything passes, a verification phase runs tests, linters, and builds. Evidence is required. "This should work" is not accepted.
The plan document doubles as a recovery mechanism. If a session dies mid-work, you pick up where you left off, every completed task is already checked off.
Where it earns its keep
The comparison with raw Claude Code is stark:
| Raw Claude Code | With Superpowers | |
|---|---|---|
| Starts with | Writing code | Asking questions |
| Test coverage | Inconsistent | TDD enforced, tests first |
| Planning | Ad-hoc | Structured, checkpoint-based |
| Review | You, manually | Automated code-reviewer agent |
| Token efficiency | Lower (more retries) | Higher (plan before execute) |
| Session recovery | Start over | Checkbox plan as state log |
That last row matters more than it sounds. Token efficiency is an underappreciated benefit. Planning is cheap; doing is expensive. A model generating a structured plan touches far less context than one reading files, writing code, running tests, and backtracking when things go wrong.
When not to bother
Not for everything. A typo fix, a variable rename, a well-understood utility function, the overhead of planning exceeds the task itself. Superpowers has a skip clarify prefix for exactly this. Use it for one-liners where the full workflow would be absurd.
And two limitations worth knowing: environment-specific debugging (wrong tool versions, Docker networking edge cases) falls outside its scope, and plans inherit spec errors. If your design document is wrong, the implementation will be wrong in the same direction. The brainstorming phase improves requirements quality significantly, but it's not infallible.
Getting started
While in Claude Code install the plugin globally:
/plugin install superpowers@claude-plugins-officialRestart Claude Code and look for the startup hook confirmation. The dispatcher activates on every session, there's nothing special you need to type. Describe what you want to build and watch the brainstorming skill fire before any code appears.
The recommendation: live with it for a week. For feature development, refactoring, and anything with meaningful complexity, it's a substantial improvement over unstructured sessions. You'll notice the difference the first time Claude asks you a question you hadn't thought of, before writing a single line of code.
Resources: GitHub · Claude Plugin Page