How to Use Claude Superpowers | TDD & Sub-Agent Automation

What Is Superpowers — A Development Methodology Plugin for Claude Code

Superpowers is an open-source plugin for Claude Code developed by Jesse Vincent. Built around the concept of "teaching systematic software development methodologies to coding tools," it provides TDD, sub-agent-driven development, debugging techniques, and more as slash commands.

It is distributed via the official Anthropic marketplace (claude.com/plugins/superpowers), and as of June 2026 has over 820,000 installs — making it one of the most downloaded Claude Code plugins available.

Rather than a simple collection of prompts, it uses a two-layer architecture of "composable skills" and an initial instruction set. Skills are loaded only when triggered, so adding a large number of skills does not bloat the context.

The source code is published under the MIT license, and the latest information can also be found on the GitHub repository (github.com/obra/superpowers).

Installation

The steps to add Superpowers to Claude Code are as follows:

1. Launch Claude Code
2. Open the official marketplace (claude.com/plugins/superpowers)
3. Click the "Install" button
4. Enter the /brainstorming command and confirm that the skill responds

No additional configuration is needed after installation — simply type a slash command to invoke a skill.

Instructions for installing Superpowers in other coding tools such as Cursor, GitHub Copilot CLI, Gemini CLI, and OpenCode are also available on the GitHub repository. Because the steps differ by platform, refer to the section for your target tool.

The 7-Step Core Workflow

The development flow defined by Superpowers consists of the following 7 steps:

1. Brainstorming — Validate the design and document requirements before writing any code
2. Git Worktrees — Prepare an isolated workspace for each task
3. Planning — Break tasks down into chunks that can be completed in 2–5 minutes
4. Sub-agent-driven development — Assign a dedicated sub-agent to each task and conduct a two-stage review
5. Test-driven development (TDD) — Strictly follow the RED-GREEN-REFACTOR cycle
6. Code review — Check quality at the end of each task
7. Branch completion — Close the cycle with a merge or PR creation

The official Superpowers page sets a goal of "going from planning to implementation in 1–2 hours." Working through every step without skipping structurally prevents ad-hoc implementation.

How to Use the TDD Skill — Enforcing RED-GREEN-REFACTOR

The TDD skill enforces the red → green → refactoring order on Claude Code.

• Red (RED) phase: Always write tests before implementing, and confirm that the tests fail before moving on
• Green (GREEN) phase: Implement the minimum amount of code to make the tests pass
• Refactoring: Improve code quality while keeping the tests green

Many developers drift toward writing tests after implementation, but Superpowers structurally prevents this. If you try to implement without tests while the skill is active, Claude will first prompt you to write tests.

For projects where the test environment has not yet been set up, the skill will ask for the test execution command at initialization time, reducing the risk of accidentally running in a "no tests" mode.

How to Use Systematic Debugging

The systematic-debugging skill provides a 4-step root-cause analysis process.

1. Record symptoms: Organize error messages, reproduction steps, and conditions under which the issue occurs
2. Form hypotheses: List possible causes and prioritize them
3. Validate hypotheses: Test hypotheses in order from most to least likely
4. Identify and fix the root cause: Fix the underlying issue, not just the surface symptom

It suppresses "just try things and fix it" debugging and encourages Claude to conduct a systematic investigation. It is especially effective when errors are chained across multiple locations or when reproduction conditions are limited.

Using this skill causes Claude to report debugging progress at each stage, making it clear which hypotheses have already been tested and what should be done next.

What Is Sub-Agent-Driven Development?

In Superpowers' sub-agent-driven development approach, a dedicated Claude instance (sub-agent) is assigned to each task, and an independent review sub-agent handles code review.

The main benefits of this approach are:

• Elimination of context contamination: Because each task operates in an independent context, residual state from previous tasks has no influence
• Separation of implementation and review: Dividing responsibilities between the implementer and the reviewer reduces oversights
• Scalability to large projects: Parallel processing increases overall project throughput

Combined with Claude Code's sub-agent functionality, this approach enables efficient progress on large-scale refactoring and new feature development. Breaking tasks down into 2–5 minute chunks during the planning phase is a prerequisite for sub-agent-driven development to work effectively.

Using the Brainstorming Feature

Invoking the /brainstorming command starts a Socratic dialogue session. Claude repeatedly asks questions to deepen understanding of requirements before any code is written, and ultimately documents the design.

The main items explored in the dialogue are:

• What is the essential problem to be solved?
• What operations and outcomes does the user expect?
• Data structure and architecture options, and the trade-offs of each
• Edge cases and error-handling scenarios

By locking down the design before writing code, you reduce the cost of changing direction midway through. It is particularly effective in situations where development tends to begin without a clear picture of "what is being built."

Supported Platforms

Superpowers is not exclusive to Claude Code — it supports multiple coding tools.

For detailed instructions per platform, refer to the platform-specific section of the GitHub repository.

The 820,000+ install count is likely driven in part by capturing users of tools other than Claude Code.

When Superpowers Works Well — and When It Doesn't

When It Works Well

• Medium-to-large feature development that can be broken into multiple tasks
• Projects where you want to increase test coverage
• Debugging systems where the root cause of bugs is hard to pin down
• Starting a project from a stage where requirements are still unclear

When It Doesn't Work As Well

• Rapid prototyping aimed purely at a quick proof of concept (adhering to the 7-step flow slows things down)
• Minor one-line to few-line edits to existing code
• Immediate application to legacy codebases without a testing environment in place

Strict adherence to the methodology is both its strength and, depending on the situation, a potential overhead. Depending on the scale and requirements of your project, you can choose between calling individual skills on their own or following all 7 steps.

Community and Support

Superpowers developer Jesse Vincent provides support via Discord, GitHub Issues, and a mailing list.

• Discord: Ask questions and share case studies with community members
• GitHub Issues: Bug reports and feature requests (github.com/obra/superpowers)
• Release notification mailing list: Receive information about new versions

Because it is published under the MIT license, you can also customize skills or add your own.

Summary

Superpowers is a plugin that instills "systematic software development methodology" in Claude Code. Its four pillars — TDD, sub-agent-driven development, Socratic brainstorming, and systematic debugging — can be easily invoked via slash commands.

As its 820,000+ install count demonstrates, it is establishing itself as a go-to tool among Claude Code users. Since it can be installed for free from the official marketplace (claude.com/plugins/superpowers), start by trying the /brainstorming command. If you have large-scale feature development or complex bug investigation coming up, the Superpowers 7-step flow is worth considering.