Superpowers for Claude Code: Install, Skills & Workflow
What the Superpowers plugin adds to Claude Code, the exact install commands from the repository, all 15 skills it ships in v7.0.2, and how its workflow differs from plain Claude Code.
TL;DR
- Superpowers is an open-source plugin of 15 composable skills — brainstorming, plans, TDD, debugging, worktrees, code review — that Claude Code loads automatically once installed.
- Install from the official marketplace with /plugin install superpowers@claude-plugins-official, or add obra/superpowers-marketplace first and install superpowers@superpowers-marketplace.
- The author's release post names Claude Code 2.0.13 or so as the minimum; the plugin manifest in the repository is v7.0.2, released 2026-11-03.
- The workflow runs brainstorm → worktree → written plan → subagent-driven or inline execution with TDD → review → finish branch. The agent checks for a relevant skill before every task.
Repository state checked 2026-11-11: 315,938 stars on GitHub, latest release v7.0.2 published 2026-11-03, latest commit 22f0b463. Star counts move daily — read it as a snapshot. Install commands, skill names and version numbers on this page are copied from these sources, not paraphrased.
What Superpowers actually is
Superpowers is an open-source, MIT-licensed plugin — v7.0.2 at the time of writing — that gives Claude Code a software-development methodology rather than another toolbelt. It is not a model, an API proxy or a fork: it is a library of 15 skills plus a bootstrap that tells the agent to find and follow them.
A skill is a folder with a SKILL.md file inside: YAML frontmatter with a name and a description, then markdown instructions. The description is the trigger — Claude Code reads it and decides whether the skill applies. Superpowers adds a session-start hook that injects a using-superpowers bootstrap, so the agent looks for a relevant skill before it answers, not after it has already written code.
It was built by Jesse Vincent (obra) at Prime Radiant and published on 2025-10-09, the same day Anthropic shipped the Claude Code plugin system. The same repository also installs into Codex, Cursor, Gemini CLI, Copilot CLI, OpenCode and others — one skill library, many harnesses.
- Version
- v7.0.2 · 2026-11-03
- Latest commit
- 22f0b463
- License
- MIT
Install Superpowers in Claude Code
Two supported routes, both copied verbatim from the repository README. Run them inside a Claude Code session — these are slash commands, not shell commands.
Route 1 — the official marketplace (one line)
Anthropic's claude-plugins-official marketplace is added automatically the first time you start an interactive Claude Code session, so you only need the install line. The README also links a listing page at claude.com/plugins/superpowers.
/plugin install superpowers@claude-plugins-officialRoute 2 — the Superpowers marketplace
Use this if you want the author's own marketplace, which also carries related plugins such as superpowers-chrome and elements-of-style. Register the marketplace once, then install the plugin by name.
/plugin marketplace add obra/superpowers-marketplace/plugin install superpowers@superpowers-marketplaceWhat you need before it works
- 1Claude Code 2.0.13 or newer — the minimum the author's release post names for the plugin flow.
- 2A restart after installing: quit and relaunch claude so the session-start hook fires and injects the bootstrap.
- 3A git repository for the full workflow — the worktree step creates an isolated branch, and the finishing step offers merge, pull request or discard.
Other harnesses, same repository
The README lists one install line per coding agent. These are copied exactly — re-read the README before running them, because commands change between releases.
| Harness | Install command |
|---|---|
| Codex CLI | /plugins |
| Cursor | /add-plugin superpowers |
| Gemini CLI | gemini extensions install https://github.com/obra/superpowers |
| Copilot CLI | copilot plugin marketplace add obra/superpowers-marketplace |
| Antigravity | agy plugin install https://github.com/obra/superpowers |
| Qwen Code | qwen extensions install obra/superpowers |
| Kimi Code | /plugins install https://github.com/obra/superpowers |
| Factory Droid | droid plugin marketplace add https://github.com/obra/superpowers |
| Grok Build | grok plugin install superpowers@xai-official --trust |
| Pi | pi install git:github.com/obra/superpowers |
| Hermes | hermes plugins install obra/superpowers --enable |
The workflow it enforces
This is the part that changes how Claude Code behaves. Seven steps from the README's Basic Workflow section, plus a rule that the agent checks for a relevant skill before any task.
- 1
brainstorming
Before anything is built the agent asks what you actually want and why, plays its understanding back for correction, and writes a design document for anything bigger than a small change.
- 2
using-git-worktrees
After design approval it creates an isolated workspace on a new branch, runs project setup and verifies a clean test baseline before touching code.
- 3
writing-plans
The approved design becomes bite-sized tasks of 2–5 minutes, each carrying exact file paths, complete code and verification steps.
- 4
subagent-driven-development or executing-plans
Two execution modes: a fresh subagent per task with a review after each (most thorough), or inline execution in the current session with one review of the whole branch at the end (cheapest).
- 5
test-driven-development
RED-GREEN-REFACTOR during implementation: write the failing test, watch it fail, write the minimum code, watch it pass, commit. Code written before its test gets deleted.
- 6
requesting-code-review
Between tasks the work is reviewed against the plan and issues are reported by severity — critical issues block progress.
- 7
finishing-a-development-branch
At the end it verifies tests, presents merge, pull request, keep or discard, executes your choice and cleans up the worktree.
All 15 skills in v7.0.2
Folder names are the identifiers the agent matches against, so they are not translated. Each description paraphrases that skill's own frontmatter in the repository at commit 22f0b463.
Testing
test-driven-development
Write the test first, watch it fail, then write only enough code to pass — with a reference of testing anti-patterns attached.
Debugging
systematic-debugging
A four-phase root-cause process for any bug, failing test or unexpected behavior, before proposing a fix. Symptom fixes count as failure.
verification-before-completion
Run the verification command and read its output before claiming work is complete, fixed or passing.
diagnosing-superpowers
When a session misbehaved, read its transcript and report what happened with line-level evidence, optionally packaging a scrubbed bundle for a bug report.
Collaboration
brainstorming
Mandatory before creative work: draws out intent through questions and plays the understanding back before anything is built.
writing-plans
Turns a spec into a plan an engineer who has never seen the codebase can execute: exact files, names, signatures and tests per task.
executing-plans
Inline plan execution — you implement task by task in the current session, with one fresh-context review of the whole branch at the end.
subagent-driven-development
A fresh implementer subagent per task, a spec-plus-quality review after each, and a broad whole-branch review at the end.
dispatching-parallel-agents
For two or more independent tasks with no shared state, delegate each to an agent with its own constructed context instead of working sequentially.
requesting-code-review
Dispatches a reviewer subagent with precisely crafted context so problems surface between tasks, not at the end.
receiving-code-review
How to handle review feedback: verify before implementing, ask before assuming, and skip performative agreement.
using-git-worktrees
Ensure an isolated workspace exists, preferring the platform's native worktree tools and falling back to manual git worktrees.
finishing-a-development-branch
Verify tests, detect the environment, present merge, PR, keep or discard, execute the choice and clean up.
Meta
writing-skills
Create and edit skills with TDD applied to process documentation, including how to test that a skill actually fires.
using-superpowers
The bootstrap skill: how to find skills, how to load them, and why they must be invoked before any response.
Superpowers vs plain Claude Code
Plain Claude Code already has plan mode, native skills, subagents, worktrees and plugins. Superpowers does not add new primitives — it adds opinions about when to use them, and a hook that makes those opinions hard to skip.
| Topic | Plain Claude Code | With Superpowers |
|---|---|---|
| Where the workflow comes from | You choose per session: plan mode, a CLAUDE.md convention, or a prompt you paste in. | A session-start hook injects a mandatory skill bootstrap, so the sequence becomes the default. |
| Planning | Plan mode produces a plan you approve, then implementation starts in the same context. | brainstorming → design document → writing-plans turns the plan into 2–5 minute tasks with file paths and tests. |
| Isolation and execution | Worktrees and subagents exist, but you decide when to reach for them. | using-git-worktrees runs automatically after design; subagent-driven-development or executing-plans is offered as a choice. |
| Quality gates | You ask for tests and review, or wire up hooks and CI yourself. | TDD, verification-before-completion and requesting-code-review fire between tasks; critical review issues block progress. |
Where it helps
- The default changes from start coding to ask first — the biggest practical difference, and the one the author's release post is built around.
- Small, readable skills: every behaviour is a markdown file you can open, diff and edit, not an opaque feature.
- One skill library across harnesses — the same repository installs into Claude Code, Codex, Cursor, Gemini CLI and more.
Where it costs you
- More tokens and more turns: questions, a design document, a plan and per-task reviews all happen before the first line of production code.
- Opinionated by design — YAGNI, strict TDD and mandatory skill invocation suit greenfield work better than a hotfix in a legacy repository.
- One more thing to keep updated, and the full benefit assumes a git repository and a harness that has subagents.
When a session misbehaves
If a skill fires when it should not, stays silent when it should, or the agent ignores its plan, the repository ships a diagnosing-superpowers skill for exactly that. Ask in the session — add "in session <id>" to inspect an earlier one — and it reads the transcript, reports what happened with evidence and can package a scrubbed bundle for a bug report.
figure out what went wrong with superpowers in session <id>Telemetry, and how to turn it off
The README is explicit: the optional visual companion in the brainstorming skill loads a logo from the Prime Radiant site, which carries the Superpowers version but no project, prompt or agent details. Set SUPERPOWERS_DISABLE_TELEMETRY to any true value to disable it; Claude Code's DISABLE_TELEMETRY and CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC are honoured too.