Superpowers: A Software Development Methodology for Your Coding Agent
Most coding agents have the same failure mode: you describe a feature and they immediately start writing code — no spec, no plan, no tests — and you spend the next hour steering them out of a ditch. Superpowers, by Jesse Vincent and the team at Prime Radiant, is built to kill that failure mode.
It’s an open-source plugin that installs a complete software development methodology into your coding agent as a library of composable, auto-triggering skills. Instead of jumping to code, the agent stops, brainstorms a spec with you, writes a detailed plan, and then builds it with disciplined TDD and self-review. This post covers what it is, how it works (including the clever bit that keeps it token-light), what practitioners think, two use cases, and the honest pros and cons.
What it is
Superpowers is a methodology shipped as skills — markdown files containing instructions, checklists, and process diagrams that the agent reads before it acts. It started as Jesse Vincent’s personal, hard-won process for working with Claude Code and was packaged as a plugin when Claude Code launched its plugin system (Simon Willison). It’s MIT-licensed, free, and now installs across many agents — Claude Code, Codex, Cursor, Gemini CLI, Pi and more.
The defining trait: the skills trigger automatically. You don’t invoke them; the agent checks for a relevant skill before any task and follows it as a mandatory workflow, not a suggestion. As the README puts it, your coding agent “just has Superpowers.”
Why it matters
- It replaces “just start coding” with a process. Clarify, design, plan, build, verify — the discipline good engineers apply, enforced on the agent every time (Builder.io).
- Real TDD, not theater. The test-driven-development skill enforces RED-GREEN-REFACTOR: write a failing test, watch it fail, write minimal code, watch it pass — and it deletes code written before its test.
- Systematic debugging. A four-phase, root-cause-first process (with techniques like backward call-stack tracing) instead of patching symptoms.
- Long autonomous runs that stay on-plan. Because the plan is broken into tiny, fully-specified tasks and dispatched to subagents with review, the agent can work for a couple of hours without drifting.
- Composable and self-extending. Skills build on each other, and there’s a
writing-skillsskill for authoring new ones.
How it works
The workflow is a pipeline of skills that hand off to each other. You approve the spec and the plan; the agent does the rest.
The cleverest part is how it stays cheap on context. Rather than dumping the whole methodology into the prompt, Superpowers loads a tiny bootstrap (under 2k tokens) and then searches for and loads only the skill it needs, when it needs it — and pushes the token-heavy implementation work onto subagents so the main conversation stays small. Jesse Vincent’s own summary: “The core of it is VERY token light.” The end-to-end planning and implementation of a todo app ran around 100k tokens (via Simon Willison).
One neat detail practitioners noticed: many skills embed a Graphviz DOT diagram of the decision process, and the agent reads those graphs as workflow instructions.
Getting started
On Claude Code it’s a two-line install from the marketplace:
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplaceAfter that there’s nothing to invoke — start describing what you want to build and the brainstorming skill takes over. Other harnesses (Codex, Cursor, Gemini CLI, Pi, etc.) each have their own one-line install; you install Superpowers separately per agent.
In practice
1. Building a feature from a vague idea. You say “I want a todo app with reminders.” Instead of generating code, the agent asks clarifying questions, drafts a spec in readable chunks for your sign-off, spins up a git worktree, writes a plan of 2–5 minute tasks (each with file paths and verification steps), then builds it task-by-task with TDD and per-task review — often running autonomously for an hour or more without drifting from the plan. Marc Nuri’s framing captures the appeal: a structured skills framework “shipped as markdown” (Marc Nuri).
2. Hunting a stubborn bug. Instead of patching where the error surfaces, the systematic-debugging skill runs a four-phase, root-cause-first process — tracing backward through the call stack to the original trigger, then adding defense-in-depth — so you fix the cause, not the symptom. This is the kind of discipline humans know they should follow and usually skip under pressure.
How it compares
Superpowers sits a level above the model and the agent — it’s process, not capability.
| Approach | What you get | Effort |
|---|---|---|
| Raw coding agent | Capable, but improvises; “just starts coding” | none |
Hand-rolled CLAUDE.md rules | Your own conventions, but you maintain them | high, ongoing |
| Superpowers | A full, tested methodology that auto-triggers | one install |
| Other skill packs | Varies; often narrower or less integrated | varies |
The honest framing: Superpowers is the most complete, opinionated take on “make the agent follow a real engineering process,” from someone Simon Willison calls one of the most creative coding-agent users he knows. If you already have a refined personal workflow encoded in your own config, you may not need it — but most people don’t, and that’s exactly the gap it fills.
Tradeoffs
- It’s opinionated by design. You get Jesse’s methodology — spec-first, TDD-always, subagent review. If you dislike mandatory TDD or want to just hack something out, the discipline is friction.
- Overkill for small edits. For a one-line fix, the brainstorm-plan-build ceremony is more process than the task warrants. It shines on real features, not typos.
- You’re trusting autonomy. Hours of unattended subagent work is powerful and a little unnerving; you still need to review the plan up front and the result at the end.
- Curated, not crowd-sourced. The maintainers generally don’t accept new community skills, so the library is consistent but less of an open free-for-all to extend.
- Optional telemetry. A visual-companion feature pings the project’s site with the version in use (no prompt/project data); it’s opt-out via an environment variable, but worth knowing it’s on by default.
Takeaway
Superpowers is the answer to “my coding agent is capable but undisciplined.” It installs a complete, auto-triggering methodology — brainstorm, plan, then build with TDD and review — and stays surprisingly light on tokens by loading skills on demand and offloading the heavy work to subagents. Reach for it when you’re building real features and want the agent to behave like a careful engineer instead of an eager intern; skip the ceremony for trivial edits. It’s one install to find out whether a process-first agent changes how much you trust the output — and for a lot of people, it has.