What are Superpowers skills?
Superpowers is an open source library of Agent Skills that turns a coding agent into a disciplined developer: it brainstorms before it builds, writes a plan, works test-first, reviews its own work, and finishes the branch cleanly. The project lives at github.com/obra/superpowers, is MIT licensed, and was built by Jesse Vincent and the team at Prime Radiant.
The README calls it "a complete software development methodology for your coding agents, built on top of a set of composable skills and some initial instructions that make sure your agent uses them." That second half is the key difference from a typical skill collection. Most collections are a shelf of separate skills you call when you need them. Superpowers is a connected set, plus a bootstrap skill that tells the agent to check for a relevant skill before every task.
It's a community project, not an Anthropic one. Anthropic does list it in its official Claude Code plugin marketplace, claude-plugins-official, where the entry says it "teaches Claude brainstorming, subagent driven development with built in code review, systematic debugging, and red/green TDD." Prime Radiant maintains it.
How does Superpowers change the way Claude Code works?
With Superpowers installed, the README says that as soon as the agent sees you're building something, it doesn't jump straight into code. Instead it "steps back and asks you what you're really trying to do." The README lays out the basic workflow as seven steps, each driven by a skill:
- brainstorming activates before building anything. It asks questions until it understands what you want and why, then plays that back for you to correct. Small changes get agreed in chat; projects get a written design document.
- using-git-worktrees activates after you approve the design. It creates an isolated workspace on a new branch, runs project setup and checks that tests pass before work starts.
- writing-plans breaks the work into bite-sized tasks of 2 to 5 minutes each, every one with exact file paths, complete code and verification steps.
- subagent-driven-development or executing-plans carries out the plan. The first sends a fresh subagent to each task with a review after each one (the README calls it the most thorough). The second does every task in the current session with one review of the whole branch at the end (the cheapest).
- test-driven-development enforces red, green, refactor: write a failing test, watch it fail, write the minimum code, watch it pass, commit. The README notes it "Deletes code written before tests."
- requesting-code-review runs between tasks, checks the work against the plan and reports issues by severity. Critical issues block progress.
- finishing-a-development-branch verifies tests, offers to merge, open a PR, keep or discard the branch, and cleans up the worktree.
The README is blunt about how strict this is: "The agent checks for relevant skills before any task. Mandatory workflows, not suggestions." It also says it's "not uncommon" for the agent to work on its own "for a couple hours at a time" once you approve a plan.
The strictness comes from the using-superpowers skill, which loads at the start of a session. Its SKILL.md tells the agent to invoke relevant skills before any response, and to run brainstorming before entering plan mode. It also sets one important limit: user instructions, such as CLAUDE.md, AGENTS.md or a direct request, "take precedence over skills."
Which skills does Superpowers include?
The skills folder holds 15 skills. The README groups them like this:
| Category | Skill | What it does, per the README |
|---|---|---|
| Testing | test-driven-development |
Red, green, refactor cycle, with a testing anti-patterns reference |
| Debugging | systematic-debugging |
A 4-phase root cause process, including root-cause tracing and defense-in-depth |
| Debugging | verification-before-completion |
Makes sure a fix actually works before it's called done |
| Debugging | diagnosing-superpowers |
Works out what went wrong in a session, with evidence |
| Collaboration | brainstorming |
Draws out intent before building |
| Collaboration | writing-plans |
Detailed implementation plans |
| Collaboration | executing-plans |
Inline plan execution with one final review |
| Collaboration | dispatching-parallel-agents |
Concurrent subagent workflows |
| Collaboration | requesting-code-review |
Pre-review checklist |
| Collaboration | receiving-code-review |
Responding to feedback |
| Collaboration | using-git-worktrees |
Parallel development branches |
| Collaboration | finishing-a-development-branch |
Merge or PR decision workflow |
| Collaboration | subagent-driven-development |
Fast iteration with a two-stage review: spec compliance, then code quality |
| Meta | writing-skills |
Create new skills following best practices, with a testing method |
| Meta | using-superpowers |
Introduction to the skills system |
Each one is a normal SKILL.md folder in the open Agent Skills format, so you can read exactly what the agent will be told before you install anything.
When a session goes off the rails, the README suggests asking your agent to "figure out what went wrong with superpowers in this session." That triggers diagnosing-superpowers, which reads the session transcript, reports what happened, and can package a scrubbed bundle for a bug report.
How do you install Superpowers in Claude Code?
Superpowers installs as a Claude Code plugin. The README documents two routes. The first uses Anthropic's official marketplace:
/plugin install superpowers@claude-plugins-official
The second uses the Superpowers marketplace, which the README says "provides Superpowers and some other related plugins for Claude Code":
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace
On updates, the README only says they are "somewhat coding-agent dependent, but are often automatic." Claude Code's own plugin docs cover updating and removing plugins.
To check it's working, start a fresh session and ask for something new to build. The README's check (given in its Muse section) uses "Let's make a react todo list": a working install triggers brainstorming before any code is written.
Does Superpowers work with Codex, Cursor and other agents?
Yes. The README has install steps for 16 harnesses (its word for coding agents and apps) and says that if you use more than one, you install Superpowers separately for each. A few of the common ones, with the commands exactly as the README gives them:
| Agent | How to install |
|---|---|
| Codex app | Plugins in the sidebar, find Superpowers in the Coding section, click + |
| Codex CLI | Run /plugins, search for superpowers, select Install Plugin |
| Cursor | In Agent chat, /add-plugin superpowers, or search the plugin marketplace |
| Gemini CLI | gemini extensions install https://github.com/obra/superpowers |
| GitHub Copilot CLI | copilot plugin marketplace add obra/superpowers-marketplace, then copilot plugin install superpowers@superpowers-marketplace |
| OpenCode | Ask it to fetch and follow the repo's .opencode/INSTALL.md |
The README also covers Antigravity, Devin CLI, Factory Droid, Grok Build CLI, Kimi Code, Pi, Qwen Code, Hermes Agent and Muse. The Codex installs go through the official Codex plugin marketplace. If you work mainly in Codex, our Codex skills guide explains how Codex finds and runs skills.
Is Superpowers worth installing?
It depends on how you like to work. The project's philosophy, from the README, is four lines: test-driven development ("Write tests first, always"), systematic over ad hoc, complexity reduction, and evidence over claims.
Where it shines: features and projects big enough to deserve a design and a plan, codebases where you want tests on everything, and long autonomous runs where you'd rather review a branch than babysit a chat. The plan format, with exact file paths and verification steps per task, makes long runs easier to check afterwards.
Where it can feel heavy: a one-line fix or a quick question. The using-superpowers skill tells the agent to invoke a skill if there is "even a 1% chance" it applies, which is the point, but it means more questions and more tokens on small jobs. Because user instructions outrank the skills, you can tell the agent to skip the process for a small change.
Two more things the README discloses. The brainstorming skill's optional visual companion loads the Prime Radiant logo from their website, which sends the Superpowers version and nothing about your project. Set SUPERPOWERS_DISABLE_TELEMETRY to any true value to turn it off; it also honors Claude Code's DISABLE_TELEMETRY and CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC. And the maintainers say "we don't generally accept contributions of new skills," so your own workflows belong in your own skills, not in a pull request.
How do you keep your own skills alongside Superpowers?
Superpowers covers process: how to plan, test and review. Your own skills cover the specifics: your release notes format, your deploy steps, your review checklist. They live side by side without trouble. Claude Code's skills docs say plugin skills are namespaced as /plugin-name:skill-name, so a skill in your ~/.claude/skills/ folder and a plugin skill both load even if the short names match.
To write a new one, you can use Superpowers' own writing-skills skill, which treats skill writing as test-driven development, or Anthropic's skill-creator. Our guide on how to write a SKILL.md covers the format by hand.
Kipt is one place to keep those personal skills: it stores your prompts and skills as Markdown in a private GitHub repo you own, and installs every skill into Claude Code or Codex with one npx skills add command, next to whatever plugins you run. For more collections worth a look, see the best Claude Code skills.