Agent frameworks#Multi-agent#Coding agent
Superpowers: a 15-skill methodology for coding agents
Superpowers is an MIT skill framework: 15 skills chain intent, planning, TDD and subagent review into one workflow across 16 coding agents.
Project facts
GitHub Ecosystem- License
- MIT
- Language
- Shell
- Stars
- 323,387
- Data checked
- 2026-11-22
Snapshot figures reflect the check date and may change over time.

If you write production code with a coding agent, you have had the same conversation more than once: explain what you want, ask for a plan, remind it to write tests first, then review everything yourself. Superpowers, started by the developer known on GitHub as obra, turns that routine into 15 skills and injects a bootstrap file at the start of every session so the skills fire on their own. As of 2026-11-22 the obra/superpowers repository has 323,387 stars and 28,693 forks, is MIT licensed, reports Shell as its primary language, and its latest release v7.0.2 shipped on 2026-11-03.

Key points
- 15 skills, in four README groups: one for testing, three for debugging, nine for collaboration, two meta skills. The
skills/directory holds exactly 15 folders, matching the README list. - 16 harnesses, install method depends on the harness: Claude Code, Codex App and Codex CLI, Cursor, Gemini CLI, GitHub Copilot CLI, Grok Build CLI, Kimi Code, OpenCode, Pi, Qwen Code, Hermes Agent, Muse, Antigravity, Devin CLI and Factory Droid. There is no universal install script.
- A fixed seven-step default: brainstorming, using-git-worktrees, writing-plans, subagent-driven-development or executing-plans, test-driven-development, requesting-code-review, finishing-a-development-branch.
Core features
What matters here is not the number of skills but the order they run in: each step’s artifact is the next step’s input, and skipping one leaves the next with nothing to work from.
- Ask before building:
brainstormingdraws out intent before any code and plays its understanding back for correction. The v7.0.2 release notes cite the maintainers’ own blind-graded runs: filler questions fell from 41 in 7.0.1 to 23, and the reason behind a request came out before any approach in 33 of 33 conversations, up from 28 of 33. That is the vendor’s own test, not a third-party benchmark. - Plans a junior could follow:
writing-plansbreaks work into tasks of two to five minutes, each with exact file paths, complete code and verification steps. The README’s bar is a plan clear enough for “an enthusiastic junior engineer with poor taste, no judgement, no project context, and an aversion to testing.” - One subagent per task:
subagent-driven-developmentdispatches a fresh subagent for each task, checks spec compliance and code quality after each one, then reviews the whole branch at the end.executing-plansis the cheaper route: implement inline in one context and review the branch once. - TDD as an iron law:
test-driven-developmentopens with “NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST” and tells the agent to delete anything written before the test.verification-before-completionadds the matching rule for claims: run the command, read the output, then say it passes. - Isolated workspaces:
using-git-worktreescreates a branch and worktree after design approval, runs project setup and confirms a clean test baseline;finishing-a-development-branchends with four options — merge, open a PR, keep, or discard — and cleans up the worktree. - Debugging and meta skills:
systematic-debuggingruns a four-phase root-cause process,diagnosing-superpowersreads a session transcript to find why a skill did or didn’t fire, andwriting-skillsdocuments how to write and test a new skill.
Sixteen harnesses
Cross-harness support is three layers, not the same files copied 16 times. Skill bodies describe actions (“invoke a skill”, “dispatch a subagent”) and never name a tool. A per-harness reference maps those actions onto real calls such as task or shell. The last layer is the bootstrap, which injects the full using-superpowers/SKILL.md into context when a session starts.
The porting guide is blunter than the README: the bootstrap is the entire integration; without it, the skill files are inert. It also sets two rules for contributors — a port may add a tool mapping and a bootstrap injector but must not reword skills/*/SKILL.md, and it must ship through the harness’s own install mechanism rather than editing a user’s global config.
| Harness | Install entry | Note |
|---|---|---|
| Claude Code | /plugin install superpowers@claude-plugins-official | In Anthropic’s marketplace; obra’s own marketplace also works |
| Cursor | /add-plugin superpowers | Run in Agent chat, or search the marketplace |
| Codex CLI | /plugins, search superpowers | Codex App lists it under Plugins, Coding section |
| Gemini CLI | gemini extensions install https://github.com/obra/superpowers | Installed as an extension; update with extensions update |
| OpenCode | Tell the agent to fetch .opencode/INSTALL.md | No install command; the agent follows the doc |
| Hermes Agent | hermes plugins install obra/superpowers --enable | No post-compaction hook, so long sessions lose the bootstrap |
What is actually enforced
This is where Superpowers is most often misread. The only piece wired into the harness is a hook: hooks/hooks.json registers a SessionStart hook matching startup|clear|compact, which calls run-hook.cmd session-start to write the bootstrap into context. Cursor’s hooks-cursor.json has a single sessionStart entry too.
Every hook in the repo only injects the bootstrap: SessionStart on Claude Code and Cursor, sessionStart on Kimi, pre_llm_call on Hermes. None intercepts a tool call the way PreToolUse would, and no git hook blocks a commit. “Delete code written before the test” and “no completion claims without fresh verification” are rules written for the model to read; whether they hold depends on the model following them. The parts a machine does enforce are elsewhere: the subagent-driven-development helper scripts (task-brief, sdd-repo, sdd-workspace, review-package) exit 2 with an instruction when arguments are wrong, the directory is not a git repo, or a code fence in the plan is unclosed.
So the honest answer to “does it enforce TDD?” is that a skill can only be as strict as the harness that injects it and the model that obeys it. That is also why the README calls out Hermes: it has no post-compaction hook, so after one long session compacts, the bootstrap is gone, skills stop firing, and you start a fresh session.
Typical use cases
- Developers tired of repeating themselves: you already ship code with Claude Code or Codex and keep adding “write the test first” to every prompt. Install it, start a session with a request, and the sequence runs.
- Teams that want the design in the repo: design docs and plans are markdown files under version control, so review means reading a diff and a plan, not scrolling a chat log.
- Long unattended runs:
subagent-driven-developmentexplicitly tells the agent not to check in between tasks. Only four things stop it: an irreversible or destructive operation, a security-sensitive action, a side effect outside the worktree, or a plan so broken every path is a guess. - People switching harnesses: the same person moves between Claude Code, Codex and Cursor and does not want three prompt sets.
Quick start
Claude Code is one command:
/plugin install superpowers@claude-plugins-official
Other harnesses use their own entry points:
# Cursor (in Agent chat)
/add-plugin superpowers
# Codex CLI: open plugin search, type superpowers, choose Install Plugin
/plugins
# Gemini CLI
gemini extensions install https://github.com/obra/superpowers
Then start a new session and say “build a React todo list”. If brainstorming asks why you want it and who it is for before any code appears, the bootstrap loaded. If the agent starts writing files immediately, check whether the harness has a SessionStart hook.
Outside reaction
The Hacker News thread from 2025-10-11 drew 435 points and 231 comments, and the skepticism was mostly about evidence: several commenters asked for A/B tests and measurable metrics rather than “it has worked over time”, and one called the all-caps EXTREMELY_IMPORTANT block SEO-style voodoo from the 2000s. Subagent cost came up too — delegating all implementation burns more tokens than working in the main context.
The positive case is specific as well. A long review published 2026-04-03 (50 points, 25 comments) argues that Claude Code’s plan mode produces a multi-page plan that is hard to review and a whole new version after every edit, while Superpowers keeps plans small and editable as markdown in the repo: “Superpowers fixes both of these issues, and more.” The comments were not unanimous — one developer said Claude made more mistakes with Superpowers and called it no silver bullet; another cited reviews saying it suits people who are not already experienced engineering managers.
On cost, notes published on simonwillison.net on 2025-10-10 quote the author: the core bootstrap is under 2k tokens, detail is fetched by shell script on demand, and token-heavy implementation goes to subagents; one full plan-and-implement conversation for a todo app reached 100k tokens. Installation has its own critics: OpenCode’s path asks the agent to fetch a document and follow it, which one Hacker News commenter described as “curl | bash but with added LLM agents”.
Summary
Use it if a coding agent is already your main tool and “it skips steps” keeps costing you afternoons, or if a team wants one fixed process and will accept seven fixed steps. If you only ask an agent for scripts now and then, or you insist on owning the process, the framework adds a layer you did not ask for — mattpocock/skills takes the opposite position and argues against frameworks taking over the workflow. If you want more skills and wider lifecycle coverage, agent-skills ships 25; Superpowers differs in subagent execution and consistency across 16 harnesses.
The license is MIT, the primary language is Shell (the skills are markdown plus a set of bash helpers), and on 2026-11-22 the repo had 323,387 stars and 28,693 forks, created 2025-10-09 with the last push on 2026-11-03. Three caveats: the skills are prompt-level constraints with no hook intercepting tool calls, so TDD depends on model compliance; the only effectiveness numbers come from the maintainers’ own blind grading, with no third-party benchmark yet; and subagent execution is more thorough but more expensive.
One default worth knowing: the optional visual companion in brainstorming loads its logo from primeradiant.com with the Superpowers version attached, but no project content; set SUPERPOWERS_DISABLE_TELEMETRY to opt out. Contribution policy is tight as well — new-skill PRs are generally declined, changes must work on every supported harness, and the maintainers do not accept agent-written fixes for issues someone else filed.