Superpowers Plugin for Claude Code: The Complete Technical Guide to TDD Guardrails, Subagents & Token Economics (2026)

You describe a feature in one sentence. The agent starts writing files before you have finished your coffee. By the time you look up, the branch is dirty, the tests were written to match the code, and you cannot remember which of those decisions you actually made.

The Superpowers plugin for Claude Code replaces chaotic vibe coding with rigid engineering scaffolding, enforcing Socratic design gates, git worktrees, and test-driven development.

The Superpowers plugin for Claude Code (obra/superpowers) transforms reactive vibe-coding into disciplined software engineering by enforcing Socratic design gates, git worktree isolation, test-driven development (TDD), and dual-stage code reviews. Installed via /plugin install superpowers@claude-plugins-official, modern versions activate automatically via session startup hooks rather than deprecated slash commands. To prevent severe token burn under frontier models, developers route routine subagents to Haiku using community forks like pcvelz/superpowers.

Last verified: 2 September 2026

That is the install answer. The part that actually changes the repo is the workflow the plugin refuses to skip.

The session most people are in looks like this. You type a reasonable request: export invoices to CSV, add a Drive sync button, patch the parser that fails on Latin-1. Claude Code (Anthropic's terminal coding agent) writes files. The tree is dirty. Tests, if they exist, were drafted after the implementation so they would pass. You approve a plan you skimmed. The Pro quota is gone before lunch.

The session that ships a branch you would merge looks different. The first turn is not code. It is a Socratic design conversation, sometimes with an HTML mockup in docs/mockups/, and a halt until you pick option 1, 2, 3, or revise. Then an isolated git worktree. Then a plan sliced into 2- to 5-minute micro-tasks. Then a failing test you can read in the terminal. Then the smallest implementation that turns that red line green. Then a code-reviewer subagent that did not write the code.

If you have ever sat in a dual-control car, you already know this job.

You are in the driver's seat. The instructor has a second brake you cannot see from the wheel. You want to pull into the gap. They will not let the car roll until you have named the mirror, the blind spot, and the turn. If you start moving before you look, the hidden pedal dumps the speed and you start from parked. That sequence is the whole lesson. Skip it and you still reach the other lane. You also collect the near-miss you will not remember until the next junction.

That hidden pedal is what the superpowers plugin claude stack is for.

Search results still mix this up. People type claude supoerpowers, superpowers claude, claude code super powers, or claude super powers and land on a commercial consulting site, a MindStudio product page, or a blog still teaching /superpowers:brainstorm. This guide is Jesse Vincent's open-source plugin, obra/superpowers, running in Claude Code. We will name the lookalikes so you do not install the wrong thing.

This will not work if you treat the plugin as a prompt trick. It is a process lock. It also will not work if you run a full multi-agent swarm on a standard Claude Pro window without a routing fork. Developers in r/ClaudeCode report that Sonnet and Fable 5 swarms can consume the daily Pro usage limit in about 30 minutes of continuous planning and execution.

Choose vanilla Claude Code for rapid disposable prototyping; deploy Superpowers when building mission-critical production systems requiring strict TDD and review gates.

Table of contents

1. Beyond Vibe Coding: How Superpowers Enforces Software Engineering Discipline

2. Installation & Ecosystem Setup: Registering Catalogs Across Claude Code, Codex, and Cursor

3. The Master Enforcer: How using-superpowers and Startup Hooks Police Agent Behavior

4. Phase 1: Socratic Brainstorming & The Design Gate (Spec Before Code)

5. Phase 2: Implementation Planning & Subagent-Driven Execution

6. Phase 3: The Iron Law of TDD & Automated Two-Stage Code Reviews

7. Operational Workflow Tuning: Resolving Git Worktree IDE Friction & "Claude Voicemail" PreToolUse Hooks

8. Token Economics & Cost Control: Mitigating Multi-Agent Swarms with the pcvelz Routing Fork

9. Frequently Asked Questions About the Superpowers Plugin for Claude

10. Closing: Next Steps for Agent Automation & Sign-Off

Beyond Vibe Coding: How Superpowers Enforces Software Engineering Discipline

Why does an unconstrained Claude Code session produce a feature you would not merge?

Because the model is doing what it is good at. It is completing. So what? Completing is not deciding.

The Reactive Vibe-Coding Trap: Hallucination and Architectural Drift

A large language model predicts the next token from a training distribution stuffed with public repos, Stack Overflow answers, and half-finished tutorials. When you ask for "add Drive sync," the highest-probability completion is the completion that showed up most often in that pile. A header button. A token hardcoded in the client. A test file written after the fact so the suite is green.

That is vibe coding: prompt, generate, glance, regenerate. It feels like pairing. It is averaging.

Architectural drift is the slow version of the same habit. Each session adds a file that almost matches the last file. Six sessions later you have three sync helpers, two token stores, and a README that describes none of them. The model did not decide to make a mess. Nobody installed a gate that made a mess more expensive than a spec.

If you have ever hit this wall on a Friday, you already know the cost. The code compiles. The product still does not have a decision record.

Jesse Vincent's SDLC Philosophy: Process Locks Over Model Guesswork

Jesse Vincent built Superpowers as a skills library for coding agents, documented in obra/superpowers and in his October 2025 write-up on blog.fsck.com. The thesis is blunt. Do not wait for a smarter model to become a senior engineer. Lock the software development lifecycle so the agent cannot skip design, isolation, tests, or review.

He tested compliance the unkind way: time pressure, "just this once" prompts, and skills that look optional until the bootstrap says they are not. The point of a superpower plugin is not a magic completion. It is a refusal to start the engine until the checklist is spoken out loud.

A skill here is a SKILL.md instruction file the agent is required to read before it acts. Superpowers ships a catalog of those files. The master one, using-superpowers, is the instructor in the passenger seat.

Superpowers enforces a strict 7-stage engineering pipeline from initial session bootstrap to git branch cleanup, preventing agentic improvisation.

The seven-stage loop, as maintainer docs and practitioner tutorials reconstruct it, is: session bootstrap, Socratic brainstorming, git worktree isolation, implementation planning, subagent dispatch, test-driven development, and two-stage review with cleanup. Vanilla Claude Code can do any one of those if you ask. Superpowers obra wiring makes skipping them a violation of the skill, not a personality trait of the model.

Disambiguation: Open-Source Framework vs. Superpower Marketplace vs. MindStudio Remy

Singular Superpower Marketplace is a commercial client-matching service with a gated revenue threshold (sources cite $1M+). Plural Superpowers Marketplace is Jesse Vincent's open-source Claude plugin catalog at obra/superpowers-marketplace. They share a word. They do not share a git remote.

MindStudio's Remy is a proprietary product-manager agent. Tutorials on mindstudio.ai walk Superpowers well, then wrap the ending around Remy. Use the workflow notes. Do not install Remy because you searched for a superpower claude skill.

If a directory site sells you "superpowers" as a $49 prompt pack, close the tab. The plugin you want is the GitHub repo, the official Anthropic marketplace listing, or the community fork we will name in the token section.

Real-World Proof: Rewriting Chardet v7.0.0 with Test-First Rigor

Pulumi's comparison of Superpowers, GSD, and GSTACK records a concrete case. The maintainer of Chardet used Superpowers to rewrite chardet v7.0.0 from scratch, reported a 41x speedup, and passed unit tests across 2,161 files. That is not a landing-page metric. It is what a test-first rewrite looks like when the agent is not allowed to invent the green bar.

A superpower plugin does not make Claude a language-encoding specialist. It makes skipping the failing test more expensive than writing it.

For a roundup of other Claude Code plugins, see best Claude Code plugins. For how Superpowers' process lock differs from GSD's per-phase XML state-to-disk model, see GSD vs Superpowers. This page stays on the product.

Installation & Ecosystem Setup: Registering Catalogs Across Claude Code, Codex, and Cursor

You do not need four catalogs. Which one are you standing in?

Installing via the Official Anthropic Marketplace (claude-plugins-official)

Start a Claude Code session in the project directory. The official one-liner from the obra/superpowers README is:

/plugin install superpowers@claude-plugins-official

That is the claude plugin superpowers path most teams should use first. It pulls the vetted listing from Anthropic's official catalog, the same marketplace family we cover in Claude Code plugin marketplace and Caveman. Auto-updates follow that registry.

Then verify:

/plugins

MindStudio's walkthrough treats /plugins as the session-level listing. You want superpowers present and enabled before you trust a SessionStart hook.

Install via the official Anthropic registry for vetted stability, Jesse Vincent's marketplace for cutting-edge skills, or the pcvelz fork for multi-model cost savings.

Registering Jesse Vincent's Curated Community Catalog (superpowers-marketplace)

If you want companion plugins from Jesse's catalog (double-shot-latte, elements-of-style, and the rest of the curated index), register the marketplace, then install from it:

/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

obra/superpowers-marketplace and the hyphen twin superpowers-marketplace are the same catalog idea: Jesse's index, not Anthropic's official store, and not the commercial Superpower Marketplace site. The core plugin is still Superpowers. The extra value is the companion skills that sit next to it.

Registering the Superpowers plugin in Claude Code via /plugin install and confirming active skills with the /plugins command.

Universal Cross-Platform Installs: OpenSkills and Codex CLI Symlinks

Superpowers is not Claude-only. DEV Community's OpenSkills guide installs the same skill pack for Cursor, Codex, and Gemini CLI:

bun add -g openskills
openskills install obra/superpowers --universal --global

OpenSkills writes into AGENTS.md via openskills sync. Platforms without native subagent dispatch (Cursor and Gemini CLI, per the same sources) fall back to sequential executing-plans instead of parallel subagents. You still get the design gate and the Iron Law. You do not get the same fan-out.

Codex native wiring, from the C# Corner guide:

gh repo clone obra/superpowers ~/.codex/superpowers
mkdir -p ~/.agents/skills
ln -s ~/.codex/superpowers/skills ~/.agents/skills/superpowers

That symlink is how Codex finds the skills directory without a Claude plugin host.

Local Cache Hierarchy and Telemetry Opt-Out (SUPERPOWERS_DISABLE_TELEMETRY)

Community-editable skills clone into ~/.config/superpowers/skills/ (the obra/superpowers-skills cache path). If you need to inspect or patch a skill, that is the folder, not a mystery npm package.

Telemetry: the README documents a Visual Companion logo ping to Prime Radiant. Opt out with:

export SUPERPOWERS_DISABLE_TELEMETRY=true

Any true-ish value works. Native DISABLE_TELEMETRY is also honored. Put the export in your shell profile if you do not want a surprise network call on session start.

Alex Followell's walkthrough is the cleanest short video of official marketplace install, /plugins verification, and kicking off plan mode. Watch it once, then come back to the commands above. The video will not mention pcvelz or worktree IDE breakage. That is our job.

https://www.youtube.com/watch?v=vfVQP2AbUHo

The Master Enforcer: How using-superpowers and Startup Hooks Police Agent Behavior

A plugin that only lives in a slash menu will be forgotten the first time you are in a hurry. Superpowers solved that by injecting itself before you type.

The SessionStart Bootstrap Injection: Eliminating Workflow Rationalization

On session start, a startup hook injects a block in the shape Jesse published:

<session-start-hook><EXTREMELY_IMPORTANT> You have Superpowers. RIGHT NOW, go read: ~/.config/superpowers/skills/getting-started/SKILL.md </EXTREMELY_IMPORTANT></session-start-hook>

Namiru.ai records the success line as SessionStart:startup hook succeeded: Success. If you do not see a hook success on a fresh session, the plugin is installed in name only.

The master rule in 0 is not polite. Paraphrased from the skill: if a skill applies to the task, the agent does not have a choice. It must use it. It cannot rationalize a shortcut because the question "looks simple."

That is how superpowers skills claude actually police behavior. Not with a dashboard. With a bootstrap that runs before the first user token.

The SessionStart hook bootstraps Superpowers into memory before user input, while project-level CLAUDE.md files maintain supreme precedence.

The 1% Trigger Rule: Mandatory Skill Invocation Before Codebase Exploration

The enforcer's trigger math is the line operators quote: if there is even a 1% chance a skill applies, invoke it. Skill check comes before clarifying questions, exploring the codebase, or opening files.

So you type "Implement invoice export to CSV." The agent does not grep src/ first. It matches a new-feature pattern, halts exploration, and loads skills/brainstorming/SKILL.md. That is the 1% trigger in practice. A superpowers skill claude session that starts by listing files has already broken the rule.

Superpowers automatically injects its master instruction hook at session start, intercepting user prompts to check for applicable skills before exploring code.

Configuration Precedence Hierarchy: CLAUDE.md, AGENTS.md, and Project Rules

Project files win. CLAUDE.md, AGENTS.md, GEMINI.md, and .cursorrules override plugin skill workflows. That is documented in the using-superpowers skill notes, not a forum rumor.

Write the exception you actually want:

# CLAUDE.md
For throwaway scripts under 20 lines, skip TDD and worktrees.
Never skip TDD for anything under src

If you do not write the exception, the plugin will apply the full lifecycle to a one-line regex. That is correct default behavior. It is also how people decide Superpowers is "too rigid" without ever opening CLAUDE.md.

Claude skills superpowers stacking with memory plugins is a different job. Persistent cross-session memory lives in claude-mem plugin, not in using-superpowers.

The Deprecated Slash Command Trap: Shifting from /superpowers:brainstorm to Automatic Triggers

Older READMEs and marketplace scrapes still tell you to run /superpowers:brainstorm, /superpowers:write-plan, and /superpowers:execute-plan. Namiru.ai, GitHub triage, and modern practitioner write-ups say those slash commands are deprecated. Skills trigger from conversational context and the SessionStart hook.

If /superpowers:brainstorm returns command not found, you are not broken. You are on a current build. Describe the feature in prose. The brainstorming skill should fire on its own.

A superpower skills claude install that still depends on slash muscle memory will feel dead. Update the habit, not the plugin.

Phase 1: Socratic Brainstorming & The Design Gate (Spec Before Code)

This is where claude code superpowers stops being a linter and becomes an architect with a clipboard.

The Design Gate: Banning Code Generation Before User Approval

Termdock quotes the architectural gate in full spirit: do not invoke any implementation skill, write any code, scaffold any project, or take any implementation action until you have presented a design and the user has approved it.

That is the dual-control brake. You can floor the accelerator. The car does not leave the curb.

WorldofAI's spec-toolkit walkthrough is the best video of this gate in motion: structured clarification, task decomposition, and the end of the "just start coding" loop.

https://www.youtube.com/watch?v=7cOAayWzYDY

What does approval actually mean? Reading the spec, picking a mockup option, and typing yes. If you approve a vague design because you are tired, the rest of the pipeline will faithfully implement the vagueness. The gate only works if you read it.

Interactive Requirements Clarification and HTML Browser Mockups

Brainstorming is Socratic, not decorative. The agent asks which user is syncing, what happens on conflict, whether the control is a header dropdown, a sidebar drawer, or an inline split button. Eric Tech's Drive-sync build shows Claude rendering HTML mockups and stopping at an approval prompt: option 1, 2, 3, or revise.

The mockup path in that walkthrough is docs/mockups/drive-sync-options.html. Treat it as a contract artifact, not a pretty extra.

The brainstorming skill generates interactive HTML mockups in docs/mockups/ and halts execution until the developer explicitly approves the design.

UI work that needs a dedicated design skill, not Superpowers' spec gate, belongs in frontend design Claude Code plugins. Superpowers will still demand a design approval. It will not pick your typeface.

Generating and Versioning Specification Documents in docs/

Approved designs land in docs/ as specification markdown, then become the input to planning. Version them. A spec that only exists in chat will be compacted away. A spec in git survives the next session, the next worktree, and the reviewer who was not in the room.

The transition from natural language to a spec file is the whole point of Phase 1. If you cannot point at a path, you do not have a gate. You have a conversation.

Phase 2: Implementation Planning & Subagent-Driven Execution

Once you approve the spec, Superpowers stops interviewing you and starts staffing the work.

Granular Decomposition: Structuring 2- to 5-Minute Micro-Tasks

Namiru.ai records the planning rule: each task takes 2 to 5 minutes maximum, written from the perspective of an enthusiastic junior engineer with no context. That constraint is how you avoid "implement Drive sync" as a single step.

A useful plan names the failing test, the file, and the done condition. A useless plan names a vibe. Superpowers-skills planning is the first kind. Approve with Proceed? (yes/no/revise). Revise in the same turn if a task is bigger than a coffee.

Subagent Dispatch vs. Sequential Inline Execution: Context Window Isolation

Claude Code and Codex can dispatch a fresh subagent per micro-task, each with a clean context window. Verdent's guide is explicit: a single mega-orchestrator that keeps everything in one chat will rot. Short-lived subagents keep the budget fresh.

Cursor and Gemini CLI, lacking native subagents, fall back to sequential executing-plans with batch checkpoints. Same skills. Different parallelism.

The deletion is the feature. The code that vanished was never going to survive a review you would have signed.

That line belongs here because planning is where people try to skip TDD "just for task 1." Task 1 is usually the test.

Superpowers prevents context exhaustion by spinning up ephemeral subagents with fresh context windows for each 2 to 5 minute micro-task.

Mitigating Session Limits and Execution Stalls with double-shot-latte

Long plans stall on "Would you like me to continue?" and on premature stops. Jesse's marketplace ships double-shot-latte@superpowers-marketplace, which evaluates whether Claude should keep working. Install it from the same catalog you registered earlier.

/plugin install double-shot-latte@superpowers-marketplace

It is not a model upgrade. It is a continuation policy. Pair it with the PreToolUse voicemail hook in the operations section if permission prompts are the actual interrupt.

Managing Hermes Engine Post-Compaction Limitations

The obra README flags a Hermes-specific hole: Hermes lacks a post-compaction hook. If a long session compactes over the first turn, the Superpowers bootstrap can disappear. Skills stop triggering mid-work. The documented recovery is a fresh session, not a pep talk.

If you are on Hermes and the 1% trigger dies after compaction, do not debug your CLAUDE.md for an hour. Start again.

Eric Tech's Google Drive sync walkthrough is the end-to-end picture of this phase: mockups, an 11-task plan, parallel subagents, and Jest. Watch it after you have the install, not before. You will recognize the prompts.

https://www.youtube.com/watch?v=TX91PdBn_IA

Phase 3: The Iron Law of TDD & Automated Two-Stage Code Reviews

This is the part blogs soften. Do not soften it.

The Iron Law: RED-GREEN-REFACTOR and the Immediate Code Deletion Penalty

Termdock and using-superpowers agree on the wording that matters: no production code without a failing test first. Write code before the test? Delete it. Start over. No exceptions.

RED: write the test, run it, watch it fail. GREEN: write the minimum implementation, watch it pass. REFACTOR: clean up while the suite stays green.

If Claude writes src/driveSync.ts before tests/driveSync.test.ts has failed in the terminal, the skill orders deletion. Operators who did not read this sentence think the plugin is buggy. It is complying.

The Iron Law of TDD in action: Claude Code executes the failing test first, rejects untested code, and only marks the task complete after tests pass green.

I tried this on a parser ticket and expected a warning. I got an empty file. Confused? Fair. The Iron Law does not negotiate. If that sentence makes you angry, Superpowers is working, and this is the wrong plugin for a spike.

Functional Review vs. Quality Review: The Independent Reviewer Subagent

MindStudio's breakdown of two-stage review is the one to keep. Pass 1 is functional: spec alignment, tests passing, no logic holes. Pass 2 is quality: readability, conventions, unnecessary dependencies. A separate code-reviewer agent runs this with a clean context, so it cannot rubber-stamp its own chat history.

That independence is the point. A self-review in the same window is a compliment, not a review.

Independent code-reviewer subagents execute a two-stage evaluation: Pass 1 verifies spec compliance and test passes, while Pass 2 audits maintainability and code quality.

The 14 Built-in Superpowers Skills Catalog

Namiru.ai maps fourteen built-in skills. You do not invoke most of them by name. They trigger from context.

The 14 built-in skills inside obra/superpowers govern every phase of the engineering lifecycle, from Socratic brainstorming to post-review branch finalization.

The set covers bootstrap (using-superpowers), design (brainstorming), planning (writing-plans), orchestration (executing-plans, subagent-driven-development), testing (test-driven-development, systematic-debugging), review (code-reviewer, requesting-code-reviews, receiving-code-reviews), completion (finishing-a-development-branch, verification-before-completion), and meta authoring (creating-skills, writing-skills). Automatic versus manual is in the table. Meta skills are the ones you opt into when you are extending the library, not shipping a feature.

finishing-a-development-branch ends with merge, PR, keep, or discard. Use it. Leaving worktrees around is how laptops fill with ../project-feature-2.

Operational Workflow Tuning: Resolving Git Worktree IDE Friction & "Claude Voicemail" PreToolUse Hooks

This is the gap most README clones skip. The plugin is correct. Your IDE is still sad.

Behind the Scenes: How Git Worktrees Sandbox Development Branches

After spec approval, Superpowers isolates work with git worktrees. Namiru.ai records the behind-the-scenes commands:

git worktree add ../project-feature feature-branch
cd ../project-feature

A worktree is a second checkout of the same repository on its own branch, in a sibling directory. Main stays clean. You can run more than one Claude instance without clobbering files. The interactive prompt may ask project-level versus global location. Pick project-level unless you have a reason.

Simon Willison highlighted the debugging skill's Graphviz decision tree: trace to the originating cause, do not patch the symptom. That is the same discipline as the worktree. Isolate the change. Then fix the real trigger.

Simon Willison's root-cause tracing workflow in Superpowers: trace the call stack to the original trigger rather than applying brittle symptom-level patches.

Solving Lost PyCharm .idea Settings and Broken Virtual Environments

r/ClaudeAI is specific. PyCharm .idea folders are often untracked. A new worktree does not have them. Local venv directories are also untracked. Tests fail because the interpreter is missing, not because the code is wrong.

Two fixes that actually work:

# from inside the worktree
ln -s ../project-main/.venv .venv

Or partially track IDE metadata if your team accepts it. Do not commit secrets from .idea. Do commit enough run configurations that a fresh checkout runs tests.

Collaborative Pair-Programming Mode: Running Superpowers Without Worktrees

If the worktree tax is too high (design review of uncommitted diffs in the same window you are typing), tell Claude not to use worktrees. Forum operators describe this as pair-programming mode: the plugin still gates design and TDD, but it works on the current tree so you can read the diff live.

Put the preference in CLAUDE.md so you do not argue with the skill every session:

Do not create git worktrees. Stay on the current working tree for pair review

You lose isolation. You gain a human-readable dirty tree. That trade is honest. It is also how you keep Superpowers without rebuilding venv every feature.

Eliminating Approval Pauses: Customizing PreToolUse for "Claude Voicemail"

Long autonomous runs die on "Would you like me to continue?" r/ClaudeCode operators customize a PreToolUse stop-hook: a local shell script that auto-replies, which they call Claude voicemail. Confidence on this one is medium. It is a community hook, not a first-party toggle in the README.

A sketch of the idea, not a blessed official script:

#!/usr/bin/env bash
# claude-voicemail.sh
# PreToolUse: auto-reply to continuation prompts during long worktree runs.
echo "Proceed"
exit 0

Wire it in Claude Code hooks the same way you wire any PreToolUse handler. Combine with double-shot-latte if the stall is a stop, not a permission prompt. Do not auto-approve destructive git commands you have not read.

A worktree checkout plus a local shell hook that answers Proceed is the shape of Claude voicemail: the session keeps running without an operator at the keyboard.

Token Economics & Cost Control: Mitigating Multi-Agent Swarms with the pcvelz Routing Fork

Here is the thing.

The same swarm that keeps context fresh is the swarm that lights the Pro meter on fire.

The 30-Minute Pro Quota Burn: The Real Cost of Multi-Agent Swarms

r/ClaudeCode threads (including "are you guys still using the superpowers skill") report that multi-agent planning and TDD on Sonnet or Fable 5 can consume a daily Claude Pro usage window in about 30 minutes of continuous work. That is not a billing scare. It is why people uninstall a plugin that is doing its job.

Can you run this all day on Pro? Not as a vanilla frontier swarm. Vanilla Superpowers runs as a frontier monolith. Every subagent thinks as hard as the parent. Design deserves that. Writing the third Jest assertion does not.

Some operators move to Max 200 ($200/month) to keep vanilla Superpowers viable. Others route.

Token Cost Matrix: Frontier Models vs. Tiered Multi-Model Architecture

The table below is a planning sketch for a 10-task build, not an invoice from Anthropic. What we can stand on from sources: the 30-minute Pro shock, and Haiku at roughly 10x cheaper for routine subagent work in the pcvelz fork.

Deploying the community-maintained pcvelz/superpowers fork slashes modeled token cost by routing repetitive 2 to 5 minute subtasks to Haiku 3.5.

Read the burgundy column first. If you cannot afford the High or Extreme rows, do not run vanilla Superpowers as an all-day loop on Pro.

Deploying the pcvelz/superpowers Extended Fork for Haiku Task Delegation

The community fork pcvelz/superpowers (v6.0.0+) hooks Claude Code's native task framework. Routine subagent tasks go to Haiku. Sonnet or Fable 5 stay on design and review. The original obra/superpowers does not natively do this, because it is built to run across Codex, Gemini CLI, and OpenCode, not only Claude's task router.

gh repo clone pcvelz/superpowers ~/.config/superpowers/pcvelz

Follow the fork's README for how it registers with Claude Code's task framework. Treat it as a production patch, not as official Anthropic support. When obra ships native routing, prefer upstream.

The pcvelz fork routes high-cognition architectural decisions to Sonnet 3.7 while offloading granular TDD cycles to Haiku 3.5, eliminating token blowouts.

Practical Exclusion Rules: When to Bypass Superpowers Entirely

Skip Superpowers for:

1. Hotfixes you can finish in under 5 minutes.

2. Open-ended prototyping where the spec is the experiment.

3. One-line regex or config edits you will throw away.

Say so in the prompt ("skip planning and TDD for this throwaway script") or in CLAUDE.md. There is no JSON toggle to disable a phase. Verbal and project-file overrides are the control surface.

Keep Superpowers for anything that will have a reviewer, a user, or a second session.

Quick-reference troubleshooting matrix for resolving deprecated slash command errors, git worktree path issues, and approval pauses in Superpowers.

Whether routing forks become first-party, or whether Hermes grows a post-compaction hook, is still open. The process lock is not. The teams that keep Superpowers are the ones who budget the swarm and write the exceptions.

Frequently Asked Questions About the Superpowers Plugin for Claude

Does the Superpowers plugin work on other IDEs or platforms besides Claude Code like Cursor?

Yes. Sources describe it as platform-agnostic across Claude Code, Codex, Cursor, Gemini CLI, and OpenCode. OpenSkills (bun add -g openskills then openskills install obra/superpowers --universal --global) is the cross-IDE path. Cursor and Gemini CLI without native subagents fall back to sequential executing-plans. You keep the gates. You lose parallel fan-out.

What actually happens if Claude writes implementation code before a test in TDD mode?

The Iron Law fires. The skill orders the agent to delete that implementation and start over. Tests are not allowed to be written retroactively to bless whatever shipped first. If you needed a spike, say so in the prompt before the skill loads.

Why are traditional slash commands like /superpowers:brainstorm failing to run?

They are deprecated in modern releases. Skills trigger from SessionStart and conversational context. Describe the bug or feature in prose. If a blog still leads with /superpowers:write-plan, it is stale relative to Namiru.ai and current triage.

Is there a way to prevent the plugin from blowing through my API limits on Sonnet or Fable 5?

Use the pcvelz/superpowers Extended fork (v6.0.0+) to route routine subagent tasks to Haiku while keeping Sonnet or Fable 5 for design and review. Alternatively raise the plan tier, or bypass Superpowers for sub-5-minute hotfixes. Vanilla obra Superpowers does not natively split models.

How does the git worktree isolation work under the hood?

After design approval, Superpowers runs git worktree add ../project-feature feature-branch and cds into that directory. You get an isolated branch and folder. Main stays clean. Multiple Claude instances can run without overwriting each other.

How do I deal with IDE settings or virtual environments when git worktrees are created?

Untracked .idea folders and venv directories do not copy. Symlink the venv (ln -s ../project-main/.venv .venv), partially track IDE metadata, or disable worktrees for pair-programming on the current tree. Put the preference in CLAUDE.md.

How does Superpowers prevent Claude from dodging the rules or improvising its own workflows?

using-superpowers injects at SessionStart. The 1% trigger rule requires a skill check before exploration or clarifying questions. Project files still override. The agent can be told to skip a phase. It cannot quietly skip a phase because the task "looked easy."

What is the Claude voicemail workflow optimization and how does it prevent constant approval prompts?

Operators wire a PreToolUse stop-hook to a local script that auto-replies to "Would you like me to continue?" pauses. That is the voicemail. It is a forum-proven hook (medium confidence), not a first-party switch. Do not auto-approve destructive commands.

How does GSD architectural approach differ from Superpowers?

Pulumi's frame: Superpowers locks process (TDD) with a single orchestrator and worktrees, suited to solo engineers. GSD locks the execution environment by writing per-phase state to disk as XML so the next phase starts with a fresh budget, suited to multi-day builds. GSTACK locks decision hierarchy with 23 simulated roles. Deep comparison belongs on GSD vs Superpowers.

Closing: Next Steps for Agent Automation & Sign-Off

The dual-control pedal is still cheap. The near-miss in traffic is not. Models will keep getting better at completing files. They will not spontaneously start refusing to write production code before a failing test unless you install a skill that deletes the shortcut.

Tonight, on one repo:

1. Run /plugin install superpowers@claude-plugins-official and confirm with /plugins.

2. Export SUPERPOWERS_DISABLE_TELEMETRY=true if you do not want the companion ping.

3. Add a CLAUDE.md exception for throwaways under 5 minutes.

4. Ask for one real feature. Approve a spec. Watch the first test fail on purpose.

5. If the Pro window dies in a single swarm, clone pcvelz/superpowers before you uninstall the discipline.

If you want the next note on this stack before it is a public post, join the newsletter. I send the commands I still run after the suite is boring, which is the goal.

Until then...

• Sage

PS. Learner cars in a lot of countries hide a second brake on the instructor side. Students swear they checked the mirror. The pedal still fires. I think about that pedal every time a test suite goes red on purpose. Check yours once this week: ask for a tiny feature, and notice whether the first new file is a test or an implementation. That is the whole quiz.