Superpowers for Claude Code: Complete Guide 2026

If you've ever tried using Claude Code to develop a complex application, you've probably encountered issues: incomplete code, skipped features, lack of testing, or improvised architecture. Superpowers solves all these problems by bringing professional software development methodologies directly into your AI workflow.

What is Superpowers?

Superpowers is an open-source agentic framework that transforms Claude Code from a simple code generator into a true senior AI developer. With over 170,634 stars on GitHub, 15,065 forks and official inclusion in the Anthropic marketplace, this plugin implements a complete 7-phase workflow that replicates the best practices of professional software development.

Unlike other AI coding tools like Cursor or GitHub Copilot that limit themselves to inline suggestions, Superpowers applies a structured methodology: Socratic brainstorming, detailed planning, Test-Driven Development (TDD), parallel sub-agent development, and systematic code review.

The Problem: Improvised AI Development

When you work normally with Claude Code, the typical flow is this:

• You give it a prompt: "Build a project management app"
• Claude immediately starts writing code
• It skips important features
• It doesn't write tests
• It creates a confusing architecture
• Result: code that barely works and is impossible to maintain

This "code-first" approach leads to:

The Solution: Professional 7-Phase Methodology

Superpowers revolutionizes this approach by implementing a systematic workflow that every senior developer would recognize. Here's how it works:

Phase 1: Socratic Brainstorming

Instead of jumping straight to code, Superpowers initiates an idea refinement process through targeted questions. It's not just a questionnaire: it's a true Socratic dialogue that:

• Explores technological alternatives (React vs Vue vs Svelte?)
• Defines functional and non-functional requirements
• Identifies constraints and dependencies
• Presents the design in digestible sections for approval
• Guides you in choosing the most suitable stack

Practical example: If you ask to create a Notion clone, Superpowers will ask:

• What stack do you prefer? (Next.js + Supabase, React + Firebase, or other?)
• Is authentication needed? What type? (OAuth, JWT, magic link?)
• Database: local or cloud?
• Real-time features necessary?
• Desired initial complexity level?

The brainstorming ends with a motivated technical recommendation, for example: "Next.js with Tailwind CSS and Supabase for the backend, because it offers..."

/superpowers:brainstorm

Phase 2: Isolated Git Worktrees

Before touching any code, Superpowers creates an isolated development branch using Git worktrees. This means:

• The main branch (main/master) remains intact
• You can experiment without fear of breaking anything
• Verified test baseline before starting
• Easy rollback if something goes wrong
• Professional workflow from enterprise teams

Phase 3: Detailed Planning

This is where the real magic happens. Superpowers breaks down the work into micro-manageable tasks of 2-5 minutes each. Not generic tasks like "Implement authentication," but specific tasks like:

• Task 1: Initialize Next.js project with TypeScript (3 min)
• Task 2: Configure Tailwind CSS and design tokens (4 min)
• Task 3: Create Supabase database schema for users (3 min)
• Task 4: Implement custom useAuth hook (5 min)
• Task 5: Create LoginForm component with validation (5 min)
• Task 6: Write e2e tests for authentication flow (4 min)

Each task includes:

• Specific files to modify or create
• Verification steps to confirm completion
• Dependencies on other tasks clearly defined
• Optimized execution order

/superpowers:write-plan

Phase 4: Subagent-Driven Development

This is one of the most innovative features. Instead of a single agent working linearly, Superpowers uses specialized sub-agents operating in parallel:

• Sub-agent A: Infrastructure setup and configuration
• Sub-agent B: UI component implementation
• Sub-agent C: Business logic and APIs
• Sub-agent D: Testing and validation

Each sub-agent:

• Works autonomously on specific tasks
• Goes through two-phase review: specification compliance + code quality
• Communicates with other agents for coordination
• Accelerates development by 3-4x compared to sequential approach

Phase 5: Test-Driven Development (TDD)

This is probably the most powerful feature of Superpowers. It rigorously applies the RED-GREEN-REFACTOR cycle:

1. RED: Write tests first (which fail because the code doesn't exist yet)
2. GREEN: Write the minimum code necessary to pass the tests
3. REFACTOR: Improve the code while keeping tests green

The iron rule: no code without preventive testing. If Claude writes code before tests, Superpowers automatically deletes it and forces it to restart with tests.

Phase 6: Systematic Code Review

Before considering a task complete, Superpowers performs an automatic code review that verifies:

• Adherence to plan specifications
• Code quality and project standards
• Adequate test coverage
• Security issues (SQL injection, XSS, etc.)
• Performance and optimizations
• Necessary documentation

Critical issues block the merge until resolution. The code-reviewer agent is also available for on-demand manual reviews.

Phase 7: Branch Completion

When all tasks are completed and tests pass, Superpowers handles the final integration:

• Verifies that all tests pass (unit, integration, e2e)
• Presents options for merge or Pull Request
• Generates documentation of changes
• Workspace and worktree cleanup
• Suggests next steps or future improvements

/superpowers:execute-plan

How to Install Superpowers

Installing Superpowers is simple and quick. There are two methods, both official:

Method 1: Claude Code Marketplace (Recommended)

Open Claude Code and type these commands:

/plugin install superpowers@claude-plugins-official

After installation, restart Claude Code:

/exit

Reopen Claude Code and you're ready to use Superpowers.

Method 2: Marketplace Discovery

Since January 2026, Superpowers is in the official Anthropic marketplace:

1. Open Claude Code
2. Type /plugin
3. Go to the "Discover" tab
4. Search for "Superpowers"
5. Press Enter to install
6. Restart with /exit

Installation Verification

To confirm that Superpowers is installed correctly, type:

/help

You should see in the list:

• /superpowers:brainstorm - Interactive idea refinement
• /superpowers:write-plan - Create implementation plan
• /superpowers:execute-plan - Execute plan with sub-agents

Real Use Case: Notion Clone

Let's see a complete practical example of how to use Superpowers to create a complex application: a Notion clone with editor, tables, and Kanban boards.

Step 1: Initialization

Open the terminal in your project folder and start Claude Code:

claude
/using-superpowers

The /using-superpowers command is essential: it reminds Claude that it has access to Superpowers skills and should use them for the entire workflow.

Step 2: Brainstorming

Start the brainstorming phase:

/superpowers:brainstorm

Your prompt:

"I want to create a web app inspired by Notion with rich text editor features, interactive tables, drag-and-drop Kanban boards, and a modern color scheme. It must be responsive and support data persistence."

Claude will start asking questions to refine the idea:

• Tech stack: Do you prefer Next.js, plain React, Vue, or other?
• Backend: Supabase, Firebase, custom backend with Node.js?
• Database: PostgreSQL, MongoDB, or other?
• Authentication: Needed? What type?
• Deployment: Vercel, Netlify, self-hosted?
• Additional features: Real-time collaboration? PDF export?

Recommendation received: Next.js 14 with App Router + Tailwind CSS + Supabase (PostgreSQL) + NextAuth for authentication.

Rationale: Next.js offers SSR and SEO optimizations, Tailwind accelerates UI development, Supabase provides managed PostgreSQL database with integrated real-time APIs.

Step 3: Planning

Once the design is approved, generate the implementation plan:

/superpowers:write-plan

Superpowers will create a detailed document with 30-40 micro tasks, for example:

Step 4: Execution

Now comes the magic moment. Start plan execution:

/superpowers:execute-plan

Claude will launch sub-agents that will start working in parallel:

• Sub-agent Setup: Initialize Next.js, install dependencies, configure Tailwind
• Sub-agent Database: Create Supabase schema with pages, tables, kanban_boards tables
• Sub-agent UI: Implement PageEditor, TableView, KanbanBoard components
• Sub-agent Testing: Write tests for each component as it's created

You'll see output similar to this:

[Subagent-Setup] Initializing Next.js project... ?
[Subagent-Setup] Installing dependencies... ?
[Subagent-Database] Creating Supabase schema... ?
[Subagent-UI] Building PageEditor component... ?
[Subagent-Testing] Writing tests for PageEditor... ?
[Code Review] Checking PageEditor implementation... ?
[Subagent-UI] Building TableView component... ?

Step 5: Error Handling

During development, you might encounter issues. For example, in the real case of the Notion clone, these emerged:

• Bug in theme color display
• Routing errors between pages
• State issues in Kanban board

Solution: Upload a screenshot of the error directly to the Claude Code terminal. Superpowers:

1. Visually analyzes the problem
2. Identifies root cause in the code
3. Automatically fixes the bug
4. Rewrites tests if necessary
5. Verifies everything works

In the specific case, it identified issues in app/globals.css (colors) and app/layout.tsx (routing), fixed the code, and got tests passing in less than 2 minutes.

Results Achieved

After about 45-60 minutes of work (mostly automated), the Notion clone had:

• Complete Next.js 14 + Tailwind CSS + Supabase setup
• Working rich text editor with formatting (bold, italic, lists, links)
• Table system with full CRUD and column sorting
• Kanban board with drag-and-drop between columns
• Data persistence on Supabase PostgreSQL
• Responsive and modern design
• 87% test coverage (unit + integration + e2e)
• Zero lines written manually

Main Superpowers Commands

Here's a quick reference to available commands:

Available Skills and Agents

In addition to the main commands, Superpowers includes an ecosystem of skills and specialized agents:

Testing Skills

• Complete TDD cycle (RED-GREEN-REFACTOR)
• References to testing anti-patterns to avoid
• Automatic generation of unit, integration, e2e tests
• Code coverage analysis and suggestions

Debugging Skills

• Root cause analysis in 4 structured phases
• Systematic debugging (not trial-and-error)
• Performance profiling and optimizations
• Stack trace and log analysis

Collaboration Skills

• Multi-developer project planning
• Automatic and manual code reviews
• Coordinated parallel workflows
• Automatic technical documentation

Code-Reviewer Agent

Specialized agent for on-demand review that checks:

• Code quality and project standards
• Security issues (OWASP Top 10)
• Performance and scalability
• Maintainability and readability
• Adequate documentation

Skill Creation Tools

You can create custom skills for your team or specific project. For example:

• Skill for your team's microservices architecture
• Skill for your company's UI standards
• Skill for specific CI/CD workflows

Comparison: Claude Code vs Superpowers

Here's a direct comparison to understand the added value:

When to Use Superpowers

Superpowers isn't for all use cases. Here's when it makes sense to use it:

Ideal For

Might Be Overkill For

Superpowers vs Alternatives

How does Superpowers position itself against other AI coding tools?

Cursor

Focus: Fast editing and intelligent autocomplete in IDE

• Pros: Great for pinpoint changes, native VS Code integration
• Cons: No structured workflow, lacks TDD methodology
• When to use: Daily editing and light refactoring

GitHub Copilot

Focus: Context-aware inline suggestions

• Pros: Fast, accurate suggestions, multi-IDE support
• Cons: Only suggestions, no architecture or planning
• When to use: Accelerate repetitive code writing

Standard Claude Code

Focus: Direct implementation from prompt to code

• Pros: Fast for simple tasks, no overhead
• Cons: No methodology, variable quality
• When to use: Simple scripts and personal projects

Superpowers

Focus: Complete TDD and subagent-driven development methodology

• Pros: Enterprise quality, robust tests, professional workflow
• Cons: Initial overhead for setup and planning
• When to use: Professional projects and mission-critical apps

Supported Platforms

Since version 5.0, Superpowers provides native multi-platform support:

• Claude Code - Primary platform, plug-and-play installation (recommended)
• Cursor - Native support
• Gemini CLI - Native support
• GitHub Copilot CLI - Native support
• Codex - Native support
• OpenCode - Native support

All platforms are automatically detected. No manual configuration required.

What's New in Version 5.0

Version 5.0 represents a major leap forward for Superpowers, introducing several groundbreaking features:

Visual Brainstorming Companion

A new browser-based interface that provides an interactive visual workspace for brainstorming sessions. Built with WebSocket communication and a zero-dependency architecture, it runs entirely in the browser with no additional packages required.

Native Multi-Platform Support

Superpowers now runs natively on multiple platforms without manual configuration:

• Claude Code (primary platform)
• Cursor
• Gemini CLI
• GitHub Copilot CLI
• Codex
• OpenCode

Automated Document Review System

A built-in system for automated review of project documentation and plans, ensuring consistency and completeness before implementation begins.

Implementer Status Protocol

New structured status reporting for sub-agents with four clear states:

• DONE - Task completed successfully
• DONE_WITH_CONCERNS - Completed but with issues to note
• BLOCKED - Cannot proceed, requires intervention
• NEEDS_CONTEXT - Additional information required

Inline Self-Review (v5.0.6)

Replaces the previous subagent review loops with an inline self-review mechanism, reducing overhead and improving review speed while maintaining code quality standards.

Continuous Plan Execution

The old "3 tasks then stop" pattern has been removed. Superpowers now executes plans continuously until completion, with intelligent checkpoints for human review when needed.

For the full changelog, see RELEASE-NOTES.md on GitHub.

Development Philosophy

Superpowers is based on solid software engineering principles:

1. Test-First Methodology

Tests always come before code. No exceptions. This ensures:

• Code testable by design
• Clear requirements before implementation
• Safe refactoring
• Living documentation (tests describe expected behavior)

2. Systematic Approach

Structured process instead of random trial-and-error. Each phase has a precise purpose and verifiable deliverables.

3. Simplicity as Primary Goal

Complexity is the enemy. Superpowers favors:

• Simple and direct solutions
• Readable and maintainable code
• Understandable architectures
• No over-engineering

4. Evidence-Based Verification

Every feature must be proven and verifiable:

• Automated tests demonstrating functionality
• Measurable quality metrics
• Code reviews based on objective checklists

5. Mandatory Workflows

Not optional suggestions but mandatory processes. The agent checks for relevant skills before each task and applies them automatically.

Limitations and Considerations

Superpowers is a powerful tool but not perfect. Here's what to keep in mind:

Not 100% Perfect

As also stated in the reference video transcript, errors can occur requiring human intervention:

• Edge-case bugs not anticipated in tests
• Integration issues with particular libraries
• Architectural decisions requiring human experience

Initial Overhead

The brainstorming and planning process requires time:

• 5-10 minutes for brainstorming
• 5-15 minutes for detailed planning
• Savings: 2-3x in implementation and debugging phase

Trade-off: Invest more time upfront, save much more later.

Learning Curve

Need to become familiar with the multi-phase workflow:

• First 2-3 sessions: slow, experimental
• After 5-10 projects: natural workflow
• After 20+ projects: 3-5x productivity compared to before

Not Officially Supported by Anthropic

Even though now in the official marketplace, Superpowers remains a community project:

• No direct support from Anthropic
• Updates depend on the community
• Possible breaking changes in future

Frequently Asked Questions (FAQ)

1. Is Superpowers really official from Anthropic?

Answer: No, Superpowers is NOT developed by Anthropic. It's an open-source project created by Jesse Vincent (obra) and the community. However, since January 15, 2026, it has been accepted into the official Anthropic Claude Code plugin marketplace, which confirms its quality and reliability. It remains a third-party project with MIT license.

2. How much does Superpowers cost?

Answer: Superpowers is completely free. It's an open-source project with MIT license. There are no hidden costs, subscriptions, or usage limits. You can use it freely for personal and commercial projects.

3. Can I use Superpowers with VS Code or other IDEs?

Answer: Yes. Since version 5.0, Superpowers natively supports Claude Code, Cursor, Gemini CLI, GitHub Copilot CLI, Codex, and OpenCode. You can use it from the terminal in any IDE (VS Code, IntelliJ, Sublime Text, etc.). It's not tied to a specific IDE and no manual configuration is needed for supported platforms.

4. Does Superpowers slow down initial development?

Answer: There's an initial overhead of 10-20 minutes for brainstorming and planning. However, this time is recovered multiplied during implementation: fewer bugs, less refactoring, less debugging. Overall for the project, Superpowers accelerates development by 2-3x compared to traditional approach.

5. Does it work for languages beyond JavaScript/TypeScript?

Answer: Yes, Superpowers is language-agnostic. It works with Python, Go, Rust, Java, C#, PHP, and any other language supported by Claude Code. The TDD methodology and workflows are universal.

6. Can I customize Superpowers workflows?

Answer: Yes. Superpowers includes "Skill Creation Tools" that allow creating custom skills for your team or project. You can define company standards, specific architectural patterns, or custom workflows.

7. Do I need to be a TDD expert to use Superpowers?

Answer: No. Superpowers guides you through the TDD process step-by-step. It's a great way to learn Test-Driven Development while developing real projects. The skills include references to anti-patterns to avoid and best practices.

8. Can Superpowers be used on existing projects?

Answer: Absolutely yes. It's particularly useful for refactoring existing codebases. Superpowers can analyze code, propose improvements, add missing tests, and modernize architecture while maintaining compatibility.

9. How does it integrate with existing CI/CD?

Answer: Superpowers generates standard code with automated tests that work with any CI/CD pipeline (GitHub Actions, GitLab CI, Jenkins, CircleCI, etc.). Tests follow the conventions of the language used.

10. Is there a community or support available?

Answer: Yes. The community is active on GitHub Discussions in the official repository. You can report bugs, propose features, and ask for help in the issue tracker: github.com/obra/superpowers/issues

Conclusions

Superpowers represents a significant evolution in the landscape of AI-assisted development tools. It's not simply a plugin that generates code faster: it's a methodological transformation that brings discipline, structure, and professional best practices into your workflow.

Who Is Superpowers For?

Superpowers is ideal if you:

• Have tried Claude Code but were disappointed by code quality
• Want to develop production-ready apps, not throwaway prototypes
• Appreciate structured methodologies like TDD and Agile
• Work on complex projects requiring reliability
• Want to learn software development best practices while building

The Future of Superpowers

Many features previously predicted have already become reality in version 5.0. With 170,634+ GitHub stars and a thriving community, Superpowers has delivered:

• Multi-platform support: Native integration with Claude Code, Cursor, Gemini CLI, GitHub Copilot CLI, Codex, and OpenCode
• Visual Brainstorming Companion: A browser-based interface for interactive brainstorming sessions
• superpowers-lab: Experimental features pipeline for testing new capabilities
• Community Skills: A growing ecosystem of community-contributed skills and workflows

Monitor updates with /plugin update superpowers or check the RELEASE-NOTES.md on GitHub.

Start Today

Ready to revolutionize your development workflow? Install Superpowers in 2 minutes:

/plugin install superpowers@claude-plugins-official

Then start your first project with /using-superpowers and discover the difference.

Useful Resources

• GitHub Repository: github.com/obra/superpowers
• Marketplace: github.com/obra/superpowers-marketplace
• Issue Tracker: github.com/obra/superpowers/issues
• Official Documentation: README in repository
• Community: GitHub Discussions
• License: MIT (Open Source)

For specific questions or personalized assistance, use the contact form at the bottom of the page.