Superpowers is the rare Claude Code plugin that's still installed in my environment months after I reviewed it — version 6.3.0 from the official marketplace, its skills firing in my real work sessions every week. That endurance is the review, in a sense. But when I first tried it, I didn't trust my impressions, so I ran an experiment: twelve Claude Code sessions, six with Superpowers installed and six without, same tasks, same prompts, a $2 spending cap per run, zero human intervention so my bias couldn't lean on the scale.
What the numbers showed was not the "10x productivity" story. It was something more specific and more useful: Superpowers doesn't make Claude smarter. It makes Claude disciplined — and whether that trade pays depends almost entirely on the size of the task. Here's the full breakdown, including the parts most reviews skip.
The problem it exists to solve
If you've spent real time with Claude Code, you know the failure pattern. You describe a feature. The agent starts writing code immediately. Fifteen minutes and a pile of tokens later, you discover it misread the requirements in the first thirty seconds — and everything since is well-built code solving the wrong problem. Before Superpowers, a meaningful share of my sessions needed at least one major course correction for exactly this reason. Not a capability gap. A methodology gap: no requirements pass, no plan, straight to implementation.
Jesse Vincent — the Keyboardio co-founder and longtime open-source toolmaker — built Superpowers to close that gap. His framing, which I've come to agree with: the fix isn't a smarter model, it's the discipline a senior lead imposes on a brilliant junior. Stop. Clarify. Plan. Then build. Then prove it's done. Superpowers packages that discipline as skills the agent follows automatically, and it's now distributed through Anthropic's official plugin marketplace.
What's actually in the box: the 14 skills
Superpowers is not one skill — it's fourteen interlocking ones, and since they're sitting in my harness I can list what each actually does rather than paraphrasing a README:
The orchestrator. using-superpowers is the dispatcher: it establishes, at the start of a conversation, that the agent should check for an applicable skill before responding at all. You never invoke it; it routes.
Ideation. brainstorming fires before creative work — new features, new components, behavior changes. It forces requirements and design exploration before implementation, and it's the skill responsible for catching the "you asked for X but you probably mean Y" gaps that used to cost me restart cycles.
Planning. writing-plans turns a spec into a detailed implementation plan; executing-plans runs a written plan in a separate session with review checkpoints. The plans are concrete — task breakdowns, file paths, ordering — and they persist as documents, which means a crashed session resumes from the plan instead of from memory.
Execution. subagent-driven-development executes a plan's independent tasks through dispatched sub-agents in the current session; dispatching-parallel-agents handles the case of two or more genuinely independent tasks running concurrently. Together they're the speed layer — parallel work on isolated scopes.
Quality gates. test-driven-development enforces red-green-refactor: failing test first, minimal code to pass, then refactor. systematic-debugging kicks in on any bug or unexpected behavior and forces root-cause work before fixes — it's the antidote to shotgun debugging, and it has rescued sessions of mine that were spiraling into token-burning guess loops. verification-before-completion is the one I'd keep if I could keep only one: before the agent claims anything is done or passing, it must run the verification commands and confirm the output. Evidence before assertions.
Code review. requesting-code-review triggers a structured review when work completes; receiving-code-review governs how feedback gets handled — with technical rigor and verification rather than performative agreement. That second one sounds minor and isn't: agents blindly implementing every review suggestion is how good code gets worse.
Git workflow. using-git-worktrees isolates feature work in a separate worktree before implementation starts — a workflow I already ran manually, as I've written about, now enforced automatically. finishing-a-development-branch closes the loop: merge, PR, or clean up, instead of leaving half-finished branches littering the repo.
The meta-skill. writing-skills lets the framework extend itself — new skills written and verified using the same TDD discipline. I've used it to build project-specific skills that integrate with the orchestration layer.
Architecturally, the important property is progressive disclosure: skills load into context only when relevant, not as a permanent 14-skill tax on every message. If you're new to how skills compose in Claude Code generally, my agent skills guide covers the underlying mechanics.
The 12-session experiment: what the numbers said
The design: two batches of six sessions each — two simple tasks (single-file utilities), two medium (multi-file features with API integration), two complex (full-stack features with schema changes, auth, and UI). Identical prompts, $2 cap per session, fully automated.
Cost and tokens. Superpowers sessions averaged roughly 9% cheaper and about 14% fewer tokens overall. Real, not dramatic. But the average concealed the actual finding:
- Simple tasks used more tokens with Superpowers. The clarify-and-plan phases interrogated tasks that had no ambiguity — planning overhead on a 50-line script is pure tax.
- Medium tasks roughly broke even on tokens while producing measurably better-structured code; planning cost was offset by fewer corrections.
- Complex tasks were where the savings concentrated. The planning phases are cheap (mostly text), and they prevented the expensive failure — thousands of lines solving the wrong problem, followed by a restart. Baseline sessions hit that failure repeatedly. Superpowers sessions mostly didn't.
The variance result that converted me. Token usage across the six Superpowers sessions clustered 2–3x tighter than baseline. Without the framework, similar complex tasks ranged from $0.80 to hitting the $2 cap — effectively a coin flip. With it, costs were predictable. If you scope client work or run agents against budgets, predictability is itself worth paying for; it's the same reason I obsess over the mechanics in my token management playbook.
Quality. Scored on correctness, structure, test coverage, and error handling, Superpowers sessions won on the first three — test coverage most clearly, since TDD means tests exist by construction rather than as an afterthought. One genuinely surprising reversal: baseline sessions handled odd edge cases marginally better a couple of times. My read is that a planned build optimizes the planned path, while an unplanned agent sometimes wanders into edge cases by accident. A real trade-off, worth knowing.
The caveats I owe you. Twelve sessions is directional, not statistical. I designed the tasks, so my biases are embedded. And most importantly: I ran the experiment fully automated, but Superpowers is designed for human-in-the-loop moments — answering its clarifying questions, reviewing its plans. My protocol bypassed the framework's best feature. Treat my numbers as a floor, not a ceiling.
Installing it, and living with it
Installation is one command from the official marketplace:
/plugin install superpowers@claude-plugins-official
Install at the user level rather than per-project — the methodology is general, and you want it everywhere. From then on it's ambient: the orchestrator reads your requests and routes through the appropriate skills without invocation. It has coexisted cleanly with everything else in my fairly crowded plugin setup — which I've documented separately — including custom project skills.
Where it grates, honestly:
- Simple tasks get ceremony they don't need. Out of the box, a ten-line fix can trigger the same methodology as a ten-file feature. Prefixing requests with "quick task, skip planning" works most of the time, but the default friction is real.
- Discipline isn't knowledge. Superpowers makes Claude methodical about your framework and domain; it doesn't teach it either. Gaps in domain context still need your CLAUDE.md or your prompts.
- Garbage in, disciplined garbage out. I watched it plan and flawlessly execute a feature that was exactly what I asked for and not what I needed. The clarifying questions catch some spec problems; they don't replace thinking.
- Team rollout needs buy-in. TDD enforcement annoys developers who don't test. Clarifying questions frustrate people who "just want it to code." Solo adoption is trivial; team adoption is a change-management exercise.
Verdict: who should install it
Install it if your work is multi-file features in codebases you'll maintain, you bill or budget agent time and need predictable costs, or your sessions keep dying to the build-the-wrong-thing restart. That's the profile where the 12-session data and my months of daily use agree: the discipline pays for itself.
Skip it (or bypass it freely) if your Claude Code usage is mostly quick scripts, prototypes, and exploration. The overhead lands exactly where the payoff doesn't.
The measure of a workflow plugin isn't its launch-week buzz — it's whether it survives in the environment of someone who tries everything. Superpowers survived mine. The reason is simple: it enforces what experienced engineers already know they should do and reliably don't make their agents do. Plan before building. Test before shipping. Verify before claiming done. My sessions didn't get smarter the day I installed it. They stopped needing to be.
Run the test yourself the way I did — a week on your real workload, with and without, watching where the numbers move. And if you're assembling a broader skills setup around it, I maintain a curated collection of Claude skills I've built and vetted for real workflows — browse the agent skills marketplace to see what's worth adding next to Superpowers in your stack.
