What Superpowers Is
Superpowers is a complete software-development methodology bolted onto Claude Code as a plugin. Created by Jesse Vincent (@obra), released October 2025, officially accepted into Anthropic's marketplace in January 2026. Current star count: ~42,000.
It's older and more mature than gstack, and its philosophy is narrower but deeper. Where gstack gives you 28 slash commands spanning CEO to QA, Superpowers focuses on the engineering discipline layer specifically: true red/green TDD, YAGNI (You Aren't Gonna Need It), and DRY (Don't Repeat Yourself).
The bet Superpowers is making: if you enforce those three principles, the rest of the "will this code hold up in production" questions mostly answer themselves.
The Loop Superpowers Enforces
When you ask a Claude Code instance with Superpowers installed to "build X," it doesn't just write code. The loop it goes through:
-
Tease a spec out of you. It asks what you're actually trying to do, not the literal thing you asked for. Often surfaces that the real problem is smaller or bigger than you stated.
-
Show you the spec in digestible chunks. Not a wall of text. Short enough to read and push back on.
-
Generate an implementation plan. Clear enough that a junior engineer could follow it. Also: easy for you to push back on before any code gets written.
-
Write the failing test first. This is the TDD enforcement. Red before green. You don't get implementation code until the test is written and confirmed failing.
-
Implement the minimum that makes the test pass. This is the YAGNI enforcement. No "while I'm here let me also add…" detours.
-
Refactor if needed. This is where DRY shows up — duplication is eliminated only once the test passes, not speculatively during the initial build.
If you've ever worked with a senior engineer who insisted on TDD + YAGNI, this will feel familiar. Superpowers is making that engineer available on demand.
Why the "happy path only" code Claude normally writes is a problem
Without Superpowers, ask Claude Code to build a feature and you usually get code that:
- Works for the obvious inputs
- Crashes on edge cases you didn't think to mention
- Has 2-3 pieces of speculative generality ("I added this helper in case you need it later")
- Passes a single happy-path test (if you're lucky — often no tests at all)
This is fine for prototypes. It's poison for production. The "iterate until it works" loop that feels fast in the first hour ends up costing 5x in the second week when edge cases start firing.
Superpowers is expensive to use for prototypes (the spec/plan/test ceremony is real overhead) but saves multiples of that cost on anything you intend to ship. The break-even is somewhere around "if you'll still be looking at this code in 2 weeks, use Superpowers."
The Superpowers Ecosystem
Superpowers is more than one repo. The author has built a small constellation:
- obra/superpowers — the core plugin
- obra/superpowers-marketplace — curated plugin marketplace (pre-dates the official Anthropic one)
- obra/superpowers-chrome — Claude Code plugin for direct Chrome browser control via DevTools Protocol. Zero dependencies.
- obra/superpowers-lab — experimental skills, new techniques being tested before going into the main plugin
- obra/superpowers-skills — community-editable skills specifically designed for Superpowers
You install just the core plugin to get the methodology. The others are additive.
Installing It
Since Superpowers was accepted into Anthropic's official marketplace in January 2026, the install is through Claude Code's plugin system rather than a git clone. The exact command is in the README at github.com/obra/superpowers — takes about 2 minutes end-to-end.
Superpowers vs. gstack: Which To Install
This is the decision most people are stuck on. Both are opinionated Claude Code plugins with large followings. Both enforce discipline. The differences:
| Dimension | Superpowers | gstack |
|---|---|---|
| Focus | Engineering discipline (TDD + YAGNI + DRY) | Full workflow (CEO → Designer → EM → QA → Ship) |
| Scope | Narrower, deeper | Broader, more surface area |
| Slash commands | Fewer, mostly implicit | 28 explicit |
| Learning curve | Steeper first week | Smoother first week |
| Long-term discipline | Higher ceiling | Broader habit coverage |
| Best for | Solo seniors, indie hackers shipping production | Founder-operators, YC-style solo builders |
If you already have a clear engineering philosophy and want it enforced ruthlessly: Superpowers. If you want to inherit a complete operational style: gstack. They overlap enough that installing both is usually redundant.
What Pairs Well With Superpowers
- claude-mem — captures your TDD rhythm across sessions so future sessions start in the same discipline
- Graphify — codebase knowledge graph, helps Superpowers' refactoring step see duplication across files (DRY enforcement)
- Anthropic's code-review plugin — runs a second review pass after Superpowers' implementation, catching what the author didn't see
Honest Limitations
Three things that make Superpowers worse than it looks in the README:
-
It's slow for prototypes. If you just want to test an idea, the spec/plan/test ceremony is overkill. You'll curse it on day-one-of-a-new-idea work.
-
You can bypass it. The plugin doesn't force anything mechanically — you can still tell Claude "skip the test, just write the code." Discipline is on you. Superpowers is a forcing function, not a hard gate.
-
TDD isn't right for everything. UI work, one-off data scripts, exploratory data analysis — these are places where TDD is real overhead and not real value. Superpowers will still push you toward tests, and you'll have to consciously override it.
None of these are disqualifying. But going in thinking "Superpowers makes everything better" sets you up for disappointment. It makes production-bound code better.
Who Should Install It
Good fit:
- Senior engineers who already believe in TDD but lapse without friction
- Indie hackers shipping real products to paying users
- Anyone who's been bitten by "works on my machine" code in production
- People doing Claude Code review but wanting a cleaner first draft to review
Bad fit:
- Prototypers and rapid experimenters
- Data scientists doing exploratory notebook work
- Teams that already have strong code review and testing culture (Superpowers will fight your process)
FAQ
Is Superpowers the same as gstack?
No. They overlap conceptually (both opinionated Claude Code plugins) but Superpowers is engineering-discipline focused while gstack is full-workflow focused.
Does it work with Cursor?
The core Superpowers methodology is largely language- and tool-agnostic, but the plugin mechanics (hook points, skill file format) target Claude Code specifically. Cursor has similar mechanisms but you'd need to port.
Is TDD actually worth it in 2026?
Long debate. My short answer: yes, for code that will still be read in a month. No, for throwaway scripts. Superpowers is designed for the first case, which is why you should install it selectively.
Does Superpowers generate working tests automatically?
Yes — test-first is the enforced pattern. Claude writes the failing test before the implementation, runs it to confirm it fails, then implements the minimum to make it pass.
What's the cost over vanilla Claude Code?
More tokens per session (spec + plan + test + implementation vs just implementation). Usually ~2x the tokens for ~10x the code quality, per my own testing. Break-even happens fast.
Does it help with the Claude Certified Architect exam?
Superpowers specifically teaches you a lot of what shows up in Domain 3 ("Claude Code Configuration & Workflows," 20% of the CCA exam) — skill file structure, hooks, slash commands. Actively using it for a month is good exam prep.
The Short Version
Superpowers is the plugin to install when you've decided you care about code quality more than code speed. It costs you discipline and ceremony to use; it pays back in code that survives production. If that trade matches where your work is, it's the best methodology plugin available for Claude Code in 2026. If your work is fast prototypes, install something lighter.