Superpowers: 14 Agent Skills That Make Claude Code Plan First
Superpowers is an MIT-licensed collection of 14 agent skills by Jesse Vincent that forces a coding agent through brainstorm, plan, test, debug, verify and review before it is allowed to say "done". Here is what each skill does, which agents it runs on, and what it actually fixes.
Verified September 18, 2026: every skill name, install command and licence below was read from the Superpowers repository and from our own pinned copy of it at revision b36e082. Star and push dates come from the GitHub API snapshot in our catalogue, taken September 4, 2026.
Superpowers is an MIT-licensed collection of 14 agent skills, written by Jesse Vincent (obra), that forces a coding agent through a full software-development lifecycle — brainstorm, plan, test, build, debug, verify, review, ship — before it is allowed to call anything done. It is the most-starred agent skills repository in the catalogue we maintain: 281,692 stars recorded on September 4, 2026, last pushed September 3, 2026.
| Superpowers at a glance | |
|---|---|
| Repository | github.com/obra/superpowers |
| Author | Jesse Vincent (obra) |
| Licence | MIT |
| Skills included | 14 |
| Stars | 281,692 (GitHub API, September 4, 2026) |
| Last push | September 3, 2026 |
| Agents supported | Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode and other Skills CLI targets |
| Requirement | Node.js 22.20 or newer for the Skills CLI install path |
| One-line install | npx skills@1 add obra/superpowers |
Most "AI coding" advice is about prompts. Superpowers is about refusal. Each skill is a written procedure the agent has to follow, and most of them exist to stop the agent doing the thing it most wants to do — start typing code.
Who uses it, and for what. The audience is the person driving the agent, not the agent: software engineers, tech leads and solo founders who hand real features to Claude Code, Codex or Cursor and have to answer for what comes back. It is used for work where a wrong assumption is expensive — a new feature, a refactor across files, a subsystem someone else will maintain — and for producing the artefacts that outlive the session: a committed design spec, a task-by-task plan, a test that went red before it went green. It is not used for typo fixes, and its own brainstorming skill says so.
What a skill actually is
An agent skill is a Markdown file with a name, a description of when to use it, and a procedure in the body. The agent matches the description, then follows the procedure instead of improvising. No fine-tuning, no runtime — instructions on disk, versioned in git.
Superpowers uses that format for process rather than knowledge. brainstorming teaches your agent no facts. It removes its permission to write code until you approve a design.
The 14 skills, by stage
| Stage | Skill | What it forces | The hard rule inside it |
|---|---|---|---|
| Entry | using-superpowers |
Check for a relevant skill before any response | Applies before clarifying questions too, not only before code |
| Intent | brainstorming |
Classify the request, present a design, stop | Spike, bounded or architectural; unsure means take the heavier path, and the ratchet never goes back down |
| Plan | writing-plans |
Turn the design into a task-by-task plan | No placeholders: no "TBD", no vague requirement survives its self-review |
| Plan | executing-plans |
Run that plan in a fresh session | A review checkpoint between every task |
| Build | test-driven-development |
Red-green-refactor | Watch the test fail first — a test that never went red proves nothing |
| Build | using-git-worktrees |
Isolate the workspace before the plan runs | Native worktree, or an equivalent isolated copy |
| Build | subagent-driven-development |
One fresh implementer subagent per task | Spec-compliance review after each task, one broad review at the end |
| Build | dispatching-parallel-agents |
Parallelise genuinely independent work | Only with no shared state and no sequential dependency |
| Fix | systematic-debugging |
Root cause before any fix | Four phases; "one more fix attempt" after two failures is a stop signal |
| Prove | verification-before-completion |
Read the command output before claiming success | Tests pass needs the output, a fix needs the original symptom retested, an agent's "done" needs the diff |
| Review | requesting-code-review |
Dispatch a reviewer subagent | It gets purpose-built context, never your session history |
| Review | receiving-code-review |
Verify feedback technically | Performative agreement is named as the failure mode |
| Ship | finishing-a-development-branch |
Decide how the work integrates | Only once tests actually pass |
| Extend | writing-skills |
Write and verify your own skills | Same format, so your repeated prompts become procedures |
Fourteen files, and the two that change agent behaviour most visibly are brainstorming and verification-before-completion: one takes away permission to start, the other takes away permission to finish. Architectural work writes a spec to docs/superpowers/specs/YYYY-MM-DD-<topic>-design.md and commits it before any code exists.
Which agents Superpowers works with
Superpowers installs on Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot and OpenCode, which is the broadest harness support of any skills repository in our catalogue. The commands below are the project's own install instructions, read from the repository on September 18, 2026:
# Any agent (Claude Code, Codex, Cursor, Gemini CLI, Copilot, OpenCode, 70+ more)
npx skills@1 add obra/superpowers
# Claude Code plugin
/plugin install superpowers@claude-plugins-official
# Codex
codex plugin marketplace add obra/superpowers-marketplace
# Gemini CLI
gemini extensions install https://github.com/obra/superpowers
# Cursor
/add-plugin superpowers
The npx skills@1 path needs Node.js 22.20 or newer; the Skills CLI states it targets 70 or more agents. Use one path only — plugin plus CLI copy leaves you with duplicate skills.
Our distribution carries pinned, licence-checked copies of all 14, recorded against upstream revision obra/superpowers@b36e082:
npx skills@1 add aiescu/agent-skills --skill brainstorming
One detail only a mixed collection exposes: skill names collide. Ours resolves the TDD collision with an owner prefix, so that skill installs as obra-test-driven-development. The other 13 keep their original names.
What it actually fixes
Three failure modes, in the order you will meet them:
- The agent codes before the intent is settled. Two sentences of brief, 300 lines back, half answering a question you never asked.
- The plan exists only in the chat. The agent agrees to an approach, then loses it three compactions later.
- "Done" is asserted, not proved. The expensive one, because you find it in production.
Superpowers ships a session-start hook that injects using-superpowers at the beginning of every conversation, which is why these rules fire at all. A skill the agent has to remember to go and read is a skill that gets read rarely.
Where it costs you
Superpowers is heavy on purpose. For a typo or a one-line configuration change the ceremony costs more than the change, and the approval gate never disappears — even a two-sentence design has to be presented and approved first. If you want small, composable skills with no opinion about your process, mattpocock/skills is the explicit counter-position and sits second in our list.
Superpowers pays when the cost of being wrong exceeds the cost of the process: most feature work, almost all architectural work, no CSS fixes.
How we use it
Across four of our product repositories — the GeekBye desktop app, the GeekBye landing site, the Keebye landing site and the GeekBye backend — Superpowers has produced 12 committed design specs and 16 implementation plans between June 4, 2026 and September 7, 2026. Every one was written before the code it describes. They sit in docs/superpowers/specs/ and docs/superpowers/plans/, named by date, and cover work such as the in-call widget UX cleanup, the product documentation hub, the interview-journey popup funnel and Keebye's billing and discount logic.
The pattern that survived contact with real work: the spec is worth more than the plan. A plan regenerates from a good spec in minutes. A spec cannot be regenerated from a plan, because the reasoning behind each decision is exactly what the plan leaves out.
New to the vocabulary — steering an agent, dispatching work, demanding proof? Our piece on Claude Code vs Codex and agent literacy covers the habits underneath it.
FAQ
What is Superpowers in Claude Code?
Superpowers is a collection of 14 agent skills by Jesse Vincent (obra) that gives Claude Code an opinionated software-development process: brainstorm, plan, TDD, debug, verify, review, ship. It installs as a Claude Code plugin with /plugin install superpowers@claude-plugins-official.
Is Superpowers free? Yes. The repository is MIT-licensed, so it is free to use, modify and redistribute, including commercially, with the original licence and copyright preserved.
Does Superpowers work with agents other than Claude Code?
Yes. It installs on Codex, Cursor, Gemini CLI, GitHub Copilot and OpenCode. The npx skills@1 add obra/superpowers route uses the Skills CLI, which states it targets 70 or more agents, and requires Node.js 22.20 or newer.
How many skills does Superpowers include?
14 skills as packaged in our distribution, pinned at upstream revision b36e082: using-superpowers, brainstorming, writing-plans, executing-plans, test-driven-development, using-git-worktrees, subagent-driven-development, dispatching-parallel-agents, systematic-debugging, verification-before-completion, requesting-code-review, receiving-code-review, finishing-a-development-branch and writing-skills.
Do I need all 14 skills?
No. Each skill is a standalone Markdown file and can be installed individually — npx skills@1 add aiescu/agent-skills --skill brainstorming gets you the entry point alone. The skills do reference each other, so a partial install means some hand-offs simply do not fire.
Does Superpowers slow the agent down? Yes, on purpose. A one-line fix still costs an approval round trip. A feature costs one design conversation and one plan file, and saves the rewrites that follow a wrong guess at your intent. In our repositories that overhead came to 28 documents in three months — one per piece of work, not one per prompt.
Is it safe to let Superpowers run things?
The skills are Markdown procedures, not executables, and every command still passes through your agent's own permission model. These skills make the agent slower to act: using-git-worktrees isolates the workspace, verification-before-completion forces it to read command output, brainstorming blocks implementation until you approve. Read any skill before installing it — ours included.
Is Superpowers better than writing my own prompts?
It is a different thing. A prompt applies to one conversation; a skill applies to every conversation that matches its description, and lives in version control where you can review and edit it. The Superpowers writing-skills skill exists precisely so you can convert your own repeated prompts into the same format.
The ten skill collections we use every day
Superpowers is the first entry in a list of ten. The other nine cover engineering habits, design taste, output discipline, token cost and app automation — and we keep the list ranked by stars fetched weekly from the GitHub API, never typed by hand.
The same repository documents the three products we build with those skills: GeekBye, the real-time interview assistant; Keebye, push-to-talk dictation for people who drive coding agents; and Pavleur, an AI meeting copilot for Mac. Each one lists which skills did which work.
The full list, the install commands and the licence records: github.com/aiescu/agent-skills
