Claude Code superpowers is the name most people use for obra's Superpowers project: fifteen skills that make the agent brainstorm, plan, test and review in a set order instead of jumping straight to code. This guide lists what each skill does, shows how they hand off to one another, gives the install commands, and says what to weigh before you leave it switched on for every session.
Everything below comes from the project's README and the skills' own descriptions in the directory. The editorial team has not run a full Superpowers session to benchmark the results, so there are no claims about speed or code quality, only about what the skills tell the agent to do.
What is Claude Code Superpowers?
The README calls Superpowers "an agentic skills framework & software development methodology." It rests on four ideas: write tests first, prefer process over guessing, keep things simple, and verify with evidence before declaring success. The skills encode those ideas as instructions the agent follows.
The distinctive part is that the skills trigger on their own. The README says the agent checks for relevant skills before any task and describes the workflows as mandatory rather than optional. The entry point is using-superpowers, whose description says it applies when starting any conversation and requires checking for a skill before any response, including clarifying questions.
The project is MIT licensed and lives at github.com/obra/superpowers. It is not limited to Claude Code. The README lists install steps for sixteen coding agents, from Codex and Cursor to Gemini CLI and GitHub Copilot CLI.
The skills, grouped by job
The README groups its library into testing, debugging, collaboration and meta skills. Each row below links to the directory page, which shows the full SKILL.md text, licence and a safety check result.
| Group | Skill | What it tells the agent to do |
|---|---|---|
| Entry point | using-superpowers | Look for and invoke a relevant skill before acting, with process skills first |
| Design | brainstorming | Clarify intent and agree on a design with you before any code is written |
| Planning | writing-plans | Turn a spec into small tasks for an engineer who has not seen the codebase |
| Workspace | using-git-worktrees | Work in an isolated workspace, using the agent's worktree tool or git worktree |
| Execution | subagent-driven-development | Give each task to a fresh subagent, review after every task and review the branch at the end |
| Execution | executing-plans | Carry out the plan inline in the current session, then run one whole-branch review |
| Execution | dispatching-parallel-agents | Split independent tasks or failures across subagents running at the same time |
| Testing | test-driven-development | Require a failing test, watched failing, before any production code |
| Review | requesting-code-review | Dispatch a reviewer subagent with a commit range, then sort findings by severity |
| Review | receiving-code-review | Check feedback against the codebase and push back with technical reasons when it is wrong |
| Debugging | systematic-debugging | Find the root cause across four ordered phases before proposing a fix |
| Verification | verification-before-completion | Run the relevant command and read its output before saying work is done |
| Wrap-up | finishing-a-development-branch | Confirm tests pass, ask how to integrate, carry it out and clean up the worktree |
| Authoring | writing-skills | Apply test-driven development to skills by running pressure scenarios with subagents |
| Diagnosis | diagnosing-superpowers | Read a session transcript and report where Superpowers went wrong, with evidence |
All fifteen show a pass result from the directory's static check and an MIT licence. The static check is a first filter, not a review of what the instructions will lead an agent to do.
How the skills chain on a feature
The README lays out a basic workflow in a fixed order. Read it as a pipeline where each skill ends by pointing at the next one.
- Brainstorming. The agent asks questions about what you actually want, explores alternatives and presents the design in sections short enough to read. Nothing gets built yet.
- Git worktrees. Once you approve the design, work moves to a new branch in an isolated workspace, with setup run and a clean test baseline confirmed.
- Writing plans. The plan breaks the work into tasks the README sizes at two to five minutes each, with exact file paths, complete code and verification steps. It is written for a reader with no project context.
- Execution. You choose between subagent-driven development, which sends a fresh subagent per task with review, and executing plans, which implements inline with a single final review. The README describes the inline route as the cheaper one.
- Test-driven development. Throughout implementation the agent follows red, green, refactor, and the skill says code written before its test gets deleted.
- Code review and finishing. Work is reviewed against the plan, critical issues block progress, and the branch skill handles the merge or pull request decision.
Two skills sit outside the pipeline and apply anywhere. Systematic debugging is a method for any bug or failing test, and verification before completion is a guard on the words "done", "fixed" and "passing". They are the two most reusable parts if you do not want the whole workflow.
How to install Superpowers in Claude Code
Superpowers is distributed as a plugin, so installation goes through Claude Code's plugin system. The README gives two routes.
Official marketplace. Run this inside a session. It opens the plugin's details so you can review what it adds and pick a scope:
/plugin install superpowers@claude-plugins-official
The project's own marketplace.
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace
Plugin scopes, updates and the /plugin panel are covered in the guide to Claude Code plugins and marketplaces. The Claude Code page in this directory lists the other ways to add a skill, including copying a single skill folder into .claude/skills/.
For other agents, the README's commands differ by tool. A few examples from it:
| Agent | Command from the README |
|---|---|
| Cursor | /add-plugin superpowers |
| Gemini CLI | gemini extensions install https://github.com/obra/superpowers |
| GitHub Copilot CLI | copilot plugin install superpowers@superpowers-marketplace |
| Codex CLI | Open /plugins, search for superpowers and select Install Plugin |
See the Codex, Cursor and Gemini CLI pages for how each of those agents loads skills. The README adds agent-specific caveats, for example that Hermes and Muse sessions need a restart after install so the bootstrap takes effect.
Using one skill without the framework
You do not have to adopt the whole pipeline. Each skill is an ordinary folder with a SKILL.md, and the directory's skill pages show install commands per agent for a single skill. Good standalone picks:
- systematic-debugging when you want root-cause discipline on bug fixes. The debugging topic compares it with other skills.
- verification-before-completion to stop unverified success claims. See the verification topic.
- test-driven-development if your team already works test-first.
- writing-skills when you are authoring your own skills. The skill authoring topic and the post on how to create a Claude skill cover the wider options.
Some skills mention their neighbors by name. A standalone copy of subagent-driven-development, for instance, assumes plans and reviewer subagents exist, so read the file before installing it alone.
Trade-offs and what to review first
Superpowers is opinionated, and the opinion has a cost.
- Process overhead. Clarifying questions, a written plan and per-task reviews make sense for a feature and feel heavy for a one-line change. The README's own cheaper path is inline execution.
- Always-on context. Enabled plugin skills have their names and descriptions in context on every turn, according to Anthropic's plugin documentation. The directory's token estimate for the largest skill, subagent-driven-development, is about eight thousand tokens once loaded, against under a thousand for using-superpowers.
- Automatic triggering. Because the skills fire without being asked, a session behaves differently from a stock Claude Code session. The README suggests asking the agent to run diagnosing-superpowers if a session goes wrong.
- Telemetry. The README says the brainstorming skill's visual companion loads a logo from the project's website, which sends the Superpowers version but not project details. It names
SUPERPOWERS_DISABLE_TELEMETRYandCLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFICas ways to turn that off. - Contributions. The README says the maintainers do not generally accept new skills, so expect a curated set that changes slowly.
Before installing any plugin, read what it adds. Anthropic's documentation warns that a plugin can run hooks and servers with your user privileges. Open the details pane, read hooks/hooks.json if one exists, and decide whether to enable auto-update for the marketplace. For skills only, the risk is mostly instructions that steer the agent, but skills that run scripts deserve a read.
Companion skills for plugin authors
The same author publishes two older skills in a separate repository for people building Claude Code plugins: developing-claude-code-plugins and working-with-claude-code. The directory shows no licence for them and the directory shows their repository last updated in December 2025, so treat them as reference material and check the current Anthropic documentation for anything version specific.
For comparisons with other process-heavy skill sets, see the subagents topic and the planning topic.
Frequently asked questions
What is Superpowers for Claude Code?
Superpowers is an open-source set of skills by obra that turns a coding agent's workflow into a fixed sequence: clarify the idea, design it, write a plan, build it task by task with reviews, and verify before claiming success. In Claude Code it installs as a plugin. The same project also supports a long list of other coding agents.
How do I install Superpowers in Claude Code?
Run /plugin install superpowers@claude-plugins-official inside a Claude Code session, which opens the plugin's details so you can pick a scope. The repository also publishes its own marketplace, which you add with /plugin marketplace add obra/superpowers-marketplace before installing superpowers@superpowers-marketplace.
Can I use one Superpowers skill without the rest?
Yes, each skill is a normal SKILL.md folder, and skill pages in this directory show per-agent install commands for a single skill. Some skills refer to others by name, though, so a lone skill can point at a step you have not installed. Systematic debugging and verification before completion stand on their own best.
What licence does Superpowers use?
The README states the MIT licence, and the directory records MIT for the fifteen skills in the main repository. Two older companion skills from a separate obra repository have no licence recorded in the directory, so check that repository before reusing them.
Does Superpowers slow Claude Code down?
It adds process on purpose. The agent asks questions, writes a plan and reviews each task before moving on, which costs time and tokens on small jobs. The README describes inline execution as the cheaper option than one fresh subagent per task.