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
Repositorygithub.com/obra/superpowers
License
MIT
Language
Shell
Stars
323,387
Data checked
2026-11-22

Snapshot figures reflect the check date and may change over time.

GitHub repository card for obra/superpowers: the repo name and an "agentic skills framework and software development methodology" tagline, the owner's avatar, and 66 contributors, 203 issues, 323k stars and 29k forks along the bottom

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.

GitHub repository card for obra/superpowers, showing the repo name, tagline and 323k stars

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: brainstorming draws 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-plans breaks 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-development dispatches a fresh subagent for each task, checks spec compliance and code quality after each one, then reviews the whole branch at the end. executing-plans is the cheaper route: implement inline in one context and review the branch once.
  • TDD as an iron law: test-driven-development opens with “NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST” and tells the agent to delete anything written before the test. verification-before-completion adds the matching rule for claims: run the command, read the output, then say it passes.
  • Isolated workspaces: using-git-worktrees creates a branch and worktree after design approval, runs project setup and confirms a clean test baseline; finishing-a-development-branch ends with four options — merge, open a PR, keep, or discard — and cleans up the worktree.
  • Debugging and meta skills: systematic-debugging runs a four-phase root-cause process, diagnosing-superpowers reads a session transcript to find why a skill did or didn’t fire, and writing-skills documents 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.

HarnessInstall entryNote
Claude Code/plugin install superpowers@claude-plugins-officialIn Anthropic’s marketplace; obra’s own marketplace also works
Cursor/add-plugin superpowersRun in Agent chat, or search the marketplace
Codex CLI/plugins, search superpowersCodex App lists it under Plugins, Coding section
Gemini CLIgemini extensions install https://github.com/obra/superpowersInstalled as an extension; update with extensions update
OpenCodeTell the agent to fetch .opencode/INSTALL.mdNo install command; the agent follows the doc
Hermes Agenthermes plugins install obra/superpowers --enableNo 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-development explicitly 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.