Superpowers for Claude Code: capabilities, tips and limits
Superpowers for Claude Code, checked at the source: what the plugin can do, how you steer and shortcut it, what it costs and where its limits lie.
by Jean Pierre Kolb ·
Superpowers has interested me since it came out as a Claude Code plugin in October 2025. I use it and think it's very good. What won me over was its range and the boost it gives Claude Code: broader workflows, planning and research led, in my experience, to a considerably more detailed and better thought-through result. Later came the interactive browser previews, which let you look at decisions and proposals quickly, before anything gets built.
My verdict up front, clearly as an assessment: Superpowers doesn't make the model any smarter. The plugin moves the work up front, so you clarify, plan, research and show first, then build. For me that's exactly where the core lies, and the individual skills are just the tools for it. That's where the difference I experience in the result comes from, and that's where the costs come from too. I can't offer you proof of effectiveness, and I don't know of an independent one for v7 either. My experience is clearly positive all the same.
The short version
| Question | Answer |
|---|---|
| What is it? | A plugin with 15 skills and one hook at session start, MIT license, also for other agents |
| What does it change? | The process: clarify, design, plan, implement with reviews. Not the model |
| Is that enforced? | No. The gates in the process are text addressed to the model, not a technical block |
| Which version do you get? | As of the retrieval date, probably 7.0.0 through the official marketplace and probably 7.0.1 through the project's marketplace |
| What does it cost? | More steps, so more tokens and time. There's no reliable figure for v7 on Claude Code |
| Is it worth it? | In my view not for the quick one-off, but yes for work where wrong assumptions get expensive |
All of this refers to version 7.0.1, retrieved on 3 November 2026. The wording keeps three things apart. "The skill instructs" means that's what the text says; what the model makes of it is open. "According to the code" means read from the source, not executed. "Checked against version 7.0.0" means reproduced there, with Claude Code 2.1.317 and only in headless mode (claude -p), not on 7.0.1 and not in the interactive interface. For model behavior, that only means "can work this way", not "always works this way".
What Superpowers is
Superpowers is a plugin, which according to the docs (opens in a new tab) means a directory of components that Claude Code installs and loads as a unit. The project (opens in a new tab) describes itself as a methodology made of composable skills and some startup instructions. It comes from Jesse Vincent and Prime Radiant, the AI research lab Vincent founded, it's under the MIT license, and for companies the README mentions commercial offerings. The announcement (opens in a new tab) came on the same day as Anthropic's plugin system.
In Claude Code it consists of two parts. The first is 15 skills; the basics are in my post on Claude Code configuration. The second is exactly one hook: according to the code, it runs on the SessionStart event for new sessions, after /clear and after a compaction (when Claude Code condenses the history), and injects the full text of the using-superpowers skill as context, around 3,400 characters. This startup text, called the "bootstrap" in the project, contains no list of skills, but rather the rule to use skills. The project calls it the entire integration and says the skill files have no effect without it. The user experiment further down doesn't confirm that so absolutely. The other skill texts load only when invoked; their descriptions, by contrast, sit in the context on every turn, according to the docs.
I like that you can read nearly the whole plugin as text. Of 84 files under skills/, 70 are Markdown and the rest mainly scripts, such as the server for the browser preview, and outside that directory, going by the source, only the hook runs in Claude Code. It stays traceable what the model is being told.
The README (opens in a new tab) names two ways to install it in Claude Code:
/plugin install superpowers@claude-plugins-official/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplaceIn a session, /plugin install first opens a dialog, according to the docs (opens in a new tab), where you choose the scope. In total the README has 16 installation sections, including for Codex, Cursor and GitHub Copilot CLI. The mechanism differs by agent.
Which version you get
As of the retrieval date, this can catch you out. The official marketplace (opens in a new tab) pins Superpowers to a fixed commit, and that commit corresponds to 7.0.0. The project's marketplace (opens in a new tab) lists 7.0.1 without a pin. So the first route should deliver 7.0.0 and the second 7.0.1. That's derived from the entries, not confirmed by an installation, and the pin can catch up at any time. According to the docs, auto-update is on for the official marketplace and off by default for others.
This matters to you because the tips about the questions change between the versions:
| Topic | 7.0.0 | 7.0.1 |
|---|---|---|
| Offer to skip the questions | In every first message | Only if brainstorming started on its own |
| Small change | Agreement in chat, no document | Short design doc with approval |
| First message | Open question about a concrete moment | Read first. With a clear request, a restatement in its own words and one targeted question; otherwise one open question with its reason |
Why text changes anything at all
According to the docs (opens in a new tab), skill text enters the context as instructions and influences what Claude does with its tools. According to the hooks docs (opens in a new tab), the hook's text gets there too, through additionalContext. That explains the effect without any program logic, and also why none of it is guaranteed. It explains the tone as well, because the startup text (opens in a new tab) is written like this:
If you think there is even a 1% chance a skill might apply to what you are doing, you ABSOLUTELY MUST invoke the skill.
IF A SKILL APPLIES TO YOUR TASK, YOU DO NOT HAVE A CHOICE. YOU MUST USE IT.That's deliberate. The project states: "LLMs respond to the same persuasion principles as humans." It maps its language to Robert Cialdini's principles, and according to the release notes the tightening was prompted by observed evasion on the agents' part. As evidence it cites Meincke et al. (opens in a new tab) with 33% versus 72% compliance. That preliminary study tested GPT-4o-mini in 28,000 conversations with objectionable requests, such as insulting the user. Coding agents and skill files weren't part of it. The expanded version (opens in a new tab) from May 2026 found 35.3% versus 51.3% across 126,000 conversations on three newer models, using requests for synthesis instructions.
I have mixed feelings about the urgent language. I understand why it's there, but it reads like pressure on the model. Right next to it, though, there's a softener: "If it turns out wrong for the situation, you don't have to use it."
The capabilities along the workflow
Going by the skill texts, it runs like this: brainstorming, then writing-plans as the only next skill, then the choice of execution, only at that point the worktree (an additional working copy of the repository), then the tasks including review, and finally finishing-a-development-branch. The README still shows an older order.
Clarifying
According to its description, the brainstorming (opens in a new tab) skill claims all creative work. Its first fork asks whether everything essential is already in the request. If so, it instructs: "This is a quick, clear task. Do it, and say what you did." Otherwise the agent is supposed to read first, because: "Never ask what the project or their context already answers."
After that, the skill instructs a conversation in which every message ends with exactly one question. The agent offers research; whether it happens is your decision. Then come two to three approaches with trade-offs and a recommendation, a design doc (the "spec") and your approval. Until then the HARD-GATE applies: "Nothing gets built until your human partner approves the design doc". The agent is supposed to write its own decisions into the doc as its own, not as your agreement. For a project, the skill says a fresh subagent first reads the doc from an implementer's point of view and reports open questions. That targets plannability, not correctness.
Superpowers doesn't lock out Plan Mode; the startup text only instructs the agent to brainstorm first. A measurement against plain Plan Mode is missing. Evan Schwartz (opens in a new tab) states having no connection to the authors and writes: "It has made my use of Claude Code so much more productive." The post describes the staged process as easier to review than the big plan document: "It's hard to review a multi-page plan." That's a single opinion from April 2026, so from before v7.
Previewing in the browser
The browser preview, called "Visual Companion" in the project, arrived with v5.0.0 in March 2026, according to the release notes. For me it's among the best parts, because it lets you look at decisions before the implementation. The skill instructs the agent to offer it as soon as seeing brings more than reading: for layouts, flows, options side by side or diagrams, and also for clickable throwaway prototypes. The offer is meant to come alone in its own message and not to return after a no. Even after a yes, requirements and trade-offs are meant to stay in text: "A question about a UI topic is not automatically a visual question."
According to the code, behind it is a local Node server that by default listens only on 127.0.0.1, with a session token in the URL. Clicks end up as a line in a file, and the skill instructs the agent to read them only after your answer in the terminal. So a click alone probably won't set the agent going, which is why you should answer in the terminal.
Planning
According to writing-plans (opens in a new tab), the plan is aimed at someone who programs idiomatically but doesn't know the code or the spec. It records the decisions: files, names and signatures, values from the spec, tests. The bodies are generally written by whoever does the implementing, because: "A plan longer than the code it describes has written the code instead." A "Review Focus" field is meant to list the most likely inputs and failure modes that no task tests yet, and each line gets a test in the plan.
Implementing
At the end of the plan the agent is supposed to ask about execution, and going by the text, this choice determines how many subagents run:
- Subagent-driven: a fresh subagent per task, then a fresh reviewer with two verdicts (spec fidelity and code quality), and at the end a review of the whole branch. The project calls it "Most thorough".
- Native: The agent implements everything in the session, and at the end a fresh reviewer on the most capable model checks it. The project calls it "Cheapest and fastest".
Both superlatives are self-assessments without numbers. What can be derived from the text: with N tasks dispatched individually, Subagent-driven starts at least 2N + 1 subagents, Native one. On top of that come up to five fix rounds per task. Only small edits of the same kind are meant to be batched. Having a fresh context do the checking rather than the author is the same idea as in the adversarial fact-check.
According to the text, both routes run straight through. Subagent-driven puts it this way: "A running plan does not wait on a human." In both cases, only four things stop the run: irreversible actions, security-critical actions, external effects such as a merge or push, and a completely broken plan. The agent decides everything else itself and logs it as a "Ruling", and at the end the full list is supposed to be in the closing message. From this you can conclude that your control sits at the start and at the end, which is exactly why the work up front weighs so heavily.
Testing, debugging, proving
The following three skills each hold what they call "The Iron Law".
test-driven-developmentdemands "NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST", and code written before the test is to be deleted. With Native that's mandatory; Subagent-driven's implementer template requires it only if the task says so, so there it depends on the plan text.systematic-debuggingdemands "NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST", four phases in a fixed order and, after three failed fixes, a conversation about the architecture. The text makes no provision for a temporary workaround in an emergency, and even lists "Quick fix for now, investigate later" among its warning signs. As an assessment, that can collide with the usual practice of stabilizing first and investigating afterward.verification-before-completionforbids success claims without a freshly run check command.
Reviewing and finishing
receiving-code-review sets "Verify before implementing" against polite nodding and prohibits sentences like "You're absolutely right!". finishing-a-development-branch offers three routes only once the test suite is green: merge locally, push and open a pull request, or leave the branch as it is, with a detached HEAD only the last two. Discarding isn't on the menu and requires the typed word discard.
Tips and tricks
If you want to be asked less
Phrase the request completely. Put what you want and why into it; then, according to the skill, the quick-task fork applies. Checked against version 7.0.0: a complete, small request can run through without a question, even without the skill loading at all. "Never asks on small tasks" would be wrong, and there's no fixed size limit.
Get out when the offer comes. If brainstorming starts on its own, 7.0.1 instructs the agent to end the first message with a one-line offer to simply get going. If you accept, the text says the skill is done and the gate goes with it. Checked against version 7.0.0: a plain "Just dive in." can trigger that, and the doc and plan then drop away. There's no fixed command. Whether test-driven-development still applies afterward hasn't been checked.
Consider what the explicit invocation does. /superpowers:brainstorming is the documented form, and /brainstorming also loads the skill (checked against version 7.0.0). Going by the text of 7.0.1, the invocation removes the offer, because whoever asks for it wants the conversation.
Bring your spec. Name the file in your first message. In 7.0.1 the skill instructs the agent to read it first and to answer in around 200 words with a restatement in its own words and one question. That doesn't skip the conversation, since the skill regards specs as often incomplete.
State the size. "This is a small change" or "This is a project": according to the skill you may overrule the classification, and if the work grows, it's supposed to scale up. The limit: going by the text of 7.0.1, the small size only shortens the doc and saves the subagent for the implementer check. Approval and writing-plans remain. Whether the short doc is created as a file is open.
Ask for a spike. "Build a quick throwaway prototype" is a real shortcut, according to the text. The project's reasoning is a thesis: "Agentic work is waterfall, but very, very fast." According to the skill, a spike gets no tests or hardly any, and plan and review drop away. The limit: "Keeping it is a new request." What you want to keep is supposed to go back through the gate, according to the skill.
If you want your own rules to apply
The startup text says: "User instructions (CLAUDE.md, AGENTS.md, GEMINI.md, etc, direct requests) take precedence over skills, which in turn override default behavior." Right after that it narrows this: "Only skip skill workflows or instructions when your human partner has explicitly told you to." I'd read the claim that your own rules take precedence as an aspiration, not a guarantee. The docs (opens in a new tab) say about CLAUDE.md: "Claude treats them as context, not enforced configuration." An official order of precedence between CLAUDE.md and skills couldn't be found in the docs. Checked against version 7.0.0: a rule in CLAUDE.md can suppress the automatic start of brainstorming, no more and no less.
According to the skill texts, preferences for spec location, plan location, worktree and execution mode are provided for. There's no configuration key or sample text, so this example doesn't come from the project:
## Working with Superpowers
- Design docs and specs live under `notes/specs/`, never under `docs/`.
- Plans live under `notes/plans/`.
- No Git worktrees, work in the current checkout.
- Run plans in this session (Native).
- Install dependencies with `npm ci`, not `npm install`.Of this, only the spec location is checked against version 7.0.0. For plan location, worktree and execution mode, "the skill instructs the agent to respect preferences" applies. The last line isn't one of the provided-for preferences; only the startup text's general precedence rule covers it. It's there because using-git-worktrees names npm install and has no lockfile rule.
The skills' subagents see your CLAUDE.md too: the templates name the general-purpose type, which according to the docs (opens in a new tab) loads it, checked against version 7.0.0. The built-in Explore and Plan types don't, and per the skill, subagents aren't meant to inherit what you only said in chat. You can also put important values into the spec, because the plan is supposed to take them verbatim into its "Global Constraints". And after a run, read the "Rulings I made" list. It's supposed to show what the agent decided without you.
If you want it to cost less
Choose Native. At the plan handoff, or in advance in CLAUDE.md. Execution with subagents costs more, but for larger work it's worth it to me. For small tasks, execution in the session is enough. The limit: nobody checks independently before the end, and on long plans the skill itself recommends subagents, because otherwise "the last tasks get the least of you".
Watch the models. The subagent-driven-development skill instructs: "Use the least powerful model that can handle each role". Mechanical tasks are meant to run cheaply, architecture and the final review on the strongest model, and the model is always meant to be set explicitly, because otherwise the session model is inherited.
That's why CLAUDE_CODE_SUBAGENT_MODEL probably often won't take effect, since according to the docs the per-call parameter takes priority. It only prevails together with CLAUDE_CODE_SUBAGENT_MODEL_FORCE=1, which, as an assessment, also overrides the skill's tiering and the stronger final review.
Run a cheaper coordinator. Say the session model is too expensive for coordination. According to the skill, the agent then starts one coordinator subagent on a mid-tier model for the whole plan under Subagent-driven. The project puts that at "about half the cost", but the release notes provide no data for it.
Measure correctly.
- According to the docs (opens in a new tab),
claude plugin details <name>shows what a plugin costs. Checked against version 7.0.0: the startup text isn't included, and the label "harness-only — no model context cost" (runs only in the tool, costs no model context) on the hook doesn't apply here. - In
/contextthe startup text sits under "Messages", also checked against version 7.0.0. - On Pro, Max, Ultra, Team and Enterprise plans,
/usagebreaks down the share of skills and plugins. - For your own comparison with and without the plugin, the docs (opens in a new tab) name
claude plugin eval. You have to create the cases first, because the release ships noevals/;claude plugin eval inithelps with that. Every run is a real model call.
Have the session diagnosed. The sentence from the README is "figure out what went wrong with superpowers in this session". diagnosing-superpowers instructs the agent to read the transcripts including subagents and to count things such as tokens per turn and the largest tool results. The limits: it's meant to deliver facts, not savings advice ("No advice to your partner either."), and costs something itself ("All seven analysts always run."). According to the text, an issue search can send search terms to GitHub without separate approval.
If you want it off
Superpowers has no switch of its own; the project points (opens in a new tab) to Claude Code: "Claude code has an existing facility to enable and disable plug-ins." Both commands are checked against version 7.0.0, and the plugin name depends on the marketplace:
# Only in this project, writes .claude/settings.local.json
claude plugin disable superpowers@claude-plugins-official --scope local
# Only for one session
claude --settings '{"enabledPlugins":{"superpowers@claude-plugins-official":false}}'You can also simply not install it globally in the first place. Four other obvious routes only go so far:
"disableAllHooks": trueremoves the startup text, but also your other hooks and, according to the docs, any custom status line and custom file suggestions. The skills stay visible and the automatic start can then fail to happen, checked against version 7.0.0, but that isn't guaranteed.- The deny rule
Skill(superpowers:brainstorming), also checked against version 7.0.0, blocks only invocation by the model, not the command you type, and the startup text still arrives. - According to the docs,
skillOverrideshas no effect on plugin skills at all. - According to the docs, a custom skill with the same name doesn't override the plugin skill; both load.
If you want your repository to stay clean
According to the skill, the default locations are docs/superpowers/specs/ and docs/superpowers/plans/, and the design doc gets committed. In a public repository it therefore goes public with your next push at the latest, unless you say otherwise. According to the code, the sdd-workspace script ignores only .superpowers/sdd/ by itself. With the --project-dir the skill instructs, according to the code the preview stores mockups and .last-token with the session token under .superpowers/brainstorm/; without the flag everything goes to /tmp. The agent is only supposed to remind you to ignore the directory. So this makes sense:
.superpowers/
.claude/worktrees/
.worktrees/For worktrees the skill instructs the agent to use the native tool first, which in Claude Code, according to the docs (opens in a new tab), puts them under .claude/worktrees/ by default. The last line only matters if the skill falls back to git worktree. If it's missing, the skill tells the agent to ignore the directory itself and commit that; adding it up front saves you that commit.
If you want the preview to stay local
According to the code, the browser loads the preview's logo from primeradiant.com, with the version number in the URL. The README openly calls this telemetry and writes "It's 100% optional", but it's on by default. A session without the preview doesn't trigger the request, but like any image request it exposes your IP address and browser identification. The telemetry is openly documented, and I give the project credit for that. I'd prefer it if it had to be switched on explicitly.
export SUPERPOWERS_DISABLE_TELEMETRY=1That only removes the logo. The browser still loads external images the agent puts into a mockup, and the preview guide names images from Unsplash as an example of real content.
The variable has to be in the environment of the server process. According to the docs, an env block in the settings also applies to subprocesses; whether it reaches the server hasn't been checked. According to the code, DISABLE_TELEMETRY and CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC also work. According to the docs, though, both reach into Claude Code itself: the first turns off its telemetry and feature-flag fetching, the second also ends automatic plugin updates.
If you want to write your own skills
I find the skill for writing skills worth reading even without the rest of the plugin, because of the idea of first watching failure without the skill. writing-skills (opens in a new tab) puts it this way: "If you didn't watch an agent fail without the skill, you don't know if the skill teaches the right thing." According to the skill, a subagent without the skill runs through a pressure scenario, meaning a task under time pressure, sunk cost or exhaustion, its excuses are noted verbatim, and then you write only against those failures. For wording tests, a control without guidance and at least five repetitions apply: "Single samples lie."
The description should name only the trigger ("Use when…"), because according to the project, agents otherwise follow the summary rather than the skill. The limit: an open issue (opens in a new tab) criticizes that the step where the agent is supposed to pass with the skill (GREEN), for skills producing an artifact such as a document or a fix, measures only compliance, not the outcome.
Limits and trade-offs
Tokens and runtime. Subagents protect the main session's context, but according to the docs (opens in a new tab): "The subagent's own requests still draw on your usage." More steps and reviews therefore cost more. That's a derivation, because the skills give no quantities. The measurements that exist all have a catch:
- AgentStackBench (opens in a new tab): Codex with gpt-5.4 instead of Claude Code, a Superpowers version from before v6, 500 tasks, and the runs with Superpowers got an additional prompt.
- With Superpowers 239 tasks were solved, without it 228. Recalculated from the raw data (opens in a new tab) with an exact McNemar test, the difference isn't statistically significant (p ≈ 0.235).
- Tokens were around 40% higher, almost entirely from cached input; uncached input rose by around 10%. Costs weren't measured.
- bartek-890 (opens in a new tab): Claude Code, v6.4.2, Sonnet 5.5, 12 tiny cases, 8 runs each with and without the plugin.
- "Superpowers changed behavior on 3 of 7 positive cases, and outcomes on 1." Costs came to 1.08 to 1.63 times, including where no skill triggered.
- The methodology (opens in a new tab) adds its own caveat: "Twelve toy Node projects are not a real codebase."
None of these numbers carry over to v7 with Claude Code, and there's no reliable measurement of runtime there.
Friction on small tasks. For a quick one-off it isn't worth it in my view. For work where wrong assumptions get expensive, it is. Going by the text, a non-trivial task without an exit has at least four points where it waits for you. Dario Radečić reaches a similar judgment in an introduction at DataCamp (opens in a new tab) from July 2026, so before v7: overkill for one-liners, worthwhile on multi-step work. I think the criticism of the questions in 7.0 is justified. The project sees it the same way and has adjusted: "Many of you told us, rightly, that the new default questions got annoying fast and felt formulaic." In the discussion thread (opens in a new tab), 7.0.1 gets only a "slightly better". That's a channel for complaints and says nothing about frequency.
Urgent language. A user experiment (opens in a new tab) with 315 sessions on v6.4.1 found that without the startup text, Sonnet 5 and Fable 5.1 often skipped matching skills, while Opus 5.5 didn't. But: "The pressure wording doesn't add anything measurable." Only triggering was measured, five runs per cell, with no multi-turn sessions and no editing tools, which the report says may have depressed the numbers without the startup text. Only the 1% block and the surrounding wrapper were replaced; "The Rule" and "Red Flags" stayed. Anthropic's prompting guide (opens in a new tab) advises toning down aggressive language around tools and skills, but it names Opus 4.5 and 4.6, not Superpowers. The project itself considers its wording tested and rejects changes without evidence from agent tests (evals).
No technical block. You should be clear that there isn't one: in the end it remains a request to the model, even with HARD-GATE written there. Only SessionStart is registered, and according to the docs that can't block anything. The README speaks of "Mandatory workflows, not suggestions", whereas the docs (opens in a new tab) call an instruction in CLAUDE.md or a skill "a request, not a guarantee".
Friction with your setup. Vanja Petreski has passed on the plugin (opens in a new tab): "It overlaps my spec, loop and review skills, and its bootstrap would compete with my rules at every start." That's a single voice, but the release also contains no test for how it works alongside other plugins.
Trust. According to the docs (opens in a new tab), a plugin can run arbitrary code with your permissions, hooks run outside the sandbox, and auto-updates can change files you've reviewed. That applies to every plugin. The Claude Code docs don't define the "Anthropic verified" badge on the listing page (opens in a new tab), and they warn that Anthropic "cannot verify that they will work as intended". For connectors, Anthropic explains a "Verified" label (opens in a new tab) as a test of quality and compatibility and writes: "It isn't a security audit". Whether that applies to plugins in the same way isn't stated there. So don't read it as a security audit. An independent security audit couldn't be found.
Pace. For me the project's pace is both a strength and a risk: a lot gets better quickly, but tips go stale just as quickly. The release notes (opens in a new tab) count 46 dated sections in 374 days, brainstorming has been rebuilt several times, and on 7.0.1 they say: "We expect to keep tuning it, but we think it's better than it was." On the dev branch, 7.0.2 is already in place as of the retrieval date, with the next rebuild of brainstorming. Even the README lags behind and still says "Small changes get agreed in chat". When in doubt, the skill text of your version is what counts.
Effectiveness. The project's own numbers don't answer the question of effectiveness. Its agent tests (opens in a new tab) measure rule compliance, by its own account, and the savings since v6 compare its own versions, not Superpowers against Claude Code without the plugin.
Conclusion
For work where wrong assumptions get expensive, Superpowers is worth it in my view. That's where the questions, design, plan and browser preview come in, before any code exists. Not so for the quick one-off, and if you already have your own spec and review processes, take an honest look at the overlap.
If you try it, read the startup text first. It's short and shows what the model is told in every session.
For this article, Claude Code supported me with creation, correction and verification, with the plugin active. The direction and the editorial responsibility are mine. There's more on that on the AI transparency page.
Further reading
Context, hooks, permissions and subagents are explained in Configuring Claude Code. Why checking belongs apart from writing is shown in Who Checks the Checker?.