Superpowers 5 for Claude Code: Visual Brainstorming, Spec Reviews, and Subagent Workflows

If you have been using Claude Code for any serious development work, you already know the feeling: the AI writes code fast, but it often skips planning, ignores tests, and drifts from the original requirements halfway through. Superpowers changes all of that. With over 82,000 GitHub stars and a v5.0 release that dropped in March 2026, this open-source plugin has become the single most popular extension in the Claude Code ecosystem. We spent the past week putting Superpowers 5 through its paces, and the results speak for themselves.

In this guide, we break down everything new in version 5.0, show you how to install it in under two minutes, and walk through the workflows that are turning solo developers into full engineering teams.

Table of Contents

• What Is Superpowers for Claude Code
• The v5.0 Feature Set
• Visual Brainstorming: HTML Replaces ASCII
• Spec Review Loops: Catching Bad Plans Before Bad Code
• Haiku Subagents: Senior Architecture, Junior Prices
• How to Install Superpowers 5
• Practical Workflow Examples
• Superpowers vs. Vanilla Claude Code
• Power User Tips
• FAQ

What Is Superpowers for Claude Code

Superpowers is an open-source agentic skills framework created by Jesse Vincent that transforms Claude Code from a reactive code generator into a structured, methodical software development partner. Think of it as the difference between handing a junior developer a ticket and pairing with a senior engineer who insists on planning before typing.

The framework enforces a specific development methodology that every experienced developer will recognize:

Brainstorm > Spec > Plan > TDD > Subagent Development > Review > Finalize

Each stage is a composable “skill” that Claude loads and follows. If Claude tries to skip a step, like writing implementation code before tests exist, Superpowers literally deletes that code and forces a restart with tests first. This is not a suggestion system. It is a hard constraint that produces dramatically better output.

Since its acceptance into the official Anthropic plugin marketplace on January 15, 2026, Superpowers has exploded in popularity. It hit number two on GitHub trending, gained 1,867 stars in a single day, and now sits at over 82,000 total stars, making it the fastest-growing developer tool on the platform in 2026. The framework is completely free, MIT-licensed, and works across Claude Code, Cursor, Codex, OpenCode, and Gemini CLI.

The v5.0 Feature Set

Version 5.0 landed on March 9, 2026, and represents the biggest update since the project launched. While previous versions focused on getting the brainstorm-to-code pipeline right, v5.0 polishes the edges that power users have been requesting for months. Here is what changed.

Three Headline Features

1. Visual Brainstorming — HTML mockups replace ASCII diagrams for design and architecture discussions
2. Spec Review Loops — A dedicated subagent validates planning documents before any code gets written
3. Optimized Subagent Routing — Cheaper models like Claude Haiku handle implementation tasks while Opus or Sonnet handles architecture

We also saw improvements to Gemini CLI support in the v5.0.1 patch release, along with a stream of bug fixes through v5.0.4. Let us dig into each headline feature.

Visual Brainstorming: HTML Replaces ASCII

This is the feature the community has been waiting for. If you have ever asked Claude Code to sketch a UI layout or diagram an architecture, you know what you get: ASCII art that sort of communicates the idea but falls apart the moment things get complex. Boxes made of dashes and pipes, arrows that point nowhere, layouts that wrap awkwardly in your terminal.

Superpowers 5 introduces Visual Brainstorming, a companion tool that generates full HTML mockups and opens them directly in your browser. Instead of squinting at a terminal trying to parse a box diagram, you get rendered layouts with proper spacing, colors, and interactive elements.

How It Works

When you start a brainstorming session with Superpowers 5, Claude still uses the built-in AskUserQuestion tool for quick choices and simple diagrams. But the moment a design conversation goes beyond what ASCII can handle, it generates an HTML file and opens it in your default browser. You see the actual layout. You can click through it. You can point at specific elements and say “move that” or “make this bigger.”

This is particularly powerful for:

• UI/UX mockups — See button placements, form layouts, and navigation flows rendered in real HTML and CSS
• Architecture diagrams — Boxes-and-arrows diagrams with proper SVG rendering, color coding, and labels that do not wrap
• Data flow visualizations — Complex pipelines and state machines that would be unreadable in ASCII
• Comparison tables — Side-by-side feature comparisons with proper formatting

The Visual Brainstorming tool is mostly tested in Claude Code and Codex environments, but Jesse Vincent notes it should work in most agents that support file creation and browser launching.

Why This Matters

Brainstorming is the first step in the Superpowers methodology. If the brainstorming output is unclear, every downstream step inherits that ambiguity. By making the brainstorming phase visual and interactive, Superpowers 5 reduces the number of “that is not what I meant” moments that derail development sessions.

Spec Review Loops: Catching Bad Plans Before Bad Code

The second major addition in v5.0 is the spec review loop, and honestly, this might be more impactful than visual brainstorming for day-to-day productivity.

Here is the problem it solves: in previous versions, Superpowers would brainstorm, write a spec, create a plan, and then hand that plan to subagents for implementation. The planning was good, but it was not infallible. Sometimes a spec would have gaps. Sometimes the plan would miss an edge case. And you would not find out until the code review stage, by which point significant tokens and time had been spent building the wrong thing.

The Two-Stage Review System

Superpowers 5 now divides the review process into two distinct agents:

Stage	Agent	What It Checks	When It Runs
Spec Review	Dedicated spec reviewer	Completeness, consistency, missing requirements, ambiguous language	After planning, before any code
Code Quality Review	Dedicated code reviewer	Implementation correctness, style, performance, test coverage	After implementation, before finalization

The spec review agent reads all planning documents and checks for:

• Missing requirements — Did the plan account for error handling? Authentication? Edge cases?
• Internal contradictions — Does step 3 assume something that step 7 invalidates?
• Ambiguous specifications — Are there phrases like “handle appropriately” that leave too much room for interpretation?
• Scope creep detection — Did the plan grow beyond what the brainstorming session agreed on?

If the spec reviewer finds issues, it reports them back before a single line of implementation code gets written. This is a massive time saver. Catching a missing requirement at the planning stage costs almost nothing. Catching it after three subagents have built features around the wrong assumption costs everything.

Real-World Impact

We tested this on a medium-complexity project, building a REST API with authentication, rate limiting, and webhook support. Without the spec review loop, Claude’s plan missed rate limiting on the webhook endpoints entirely. The code review caught it, but only after the implementation subagents had already built the webhook system without rate limiting, requiring a significant rework.

With the spec review loop enabled, the spec reviewer flagged the inconsistency before any code was written. The fix took thirty seconds at the planning stage instead of fifteen minutes at the code review stage.

Haiku Subagents: Senior Architecture, Junior Prices

The third headline feature is less flashy but arguably the most practical for teams watching their API bills: intelligent model routing for subagent tasks.

Superpowers has always supported subagent-driven development, where Claude launches fresh subagents to handle individual tasks from the plan. What is new in v5.0 is that the framework now explicitly instructs the orchestrating agent to use the cheapest model capable of each task.

How Model Routing Works

When Superpowers creates a detailed plan through its brainstorm-then-plan process, each task in that plan comes with enough context and specification that a less powerful model can execute it reliably. The detailed plans essentially “pre-chew” the work so that implementation becomes mechanical.

In Claude Code, this means:

• Claude Opus or Sonnet handles brainstorming, planning, spec review, and code review, the tasks that require judgment and creativity
• Claude Haiku handles implementation tasks, the tasks that require following a clear specification and writing code to match

The result is dramatic cost savings without quality loss. Developers report that with detailed enough plans, Haiku implements features correctly on the first pass the majority of the time. When it does not, the two-stage review system catches issues before they compound.

Cost Comparison

Workflow	Model Usage	Relative Cost
Vanilla Claude Code (Sonnet for everything)	Sonnet for all tasks	Baseline
Superpowers v4 (Sonnet subagents)	Sonnet for planning + Sonnet for implementation	~1.5x baseline (more tokens, but better output)
Superpowers v5 (Haiku subagents)	Sonnet for planning + Haiku for implementation	~0.6x baseline

You read that right. Superpowers 5 with Haiku subagents can actually cost less than vanilla Claude Code while producing significantly better, more tested, more thoroughly reviewed output. The structured planning means fewer wasted tokens on wrong approaches, and the cheaper implementation model more than offsets the tokens spent on planning and review.

How to Install Superpowers 5

Installation takes about ninety seconds. Superpowers is available through the official Anthropic plugin marketplace.

Step 1: Add the Marketplace

Open Claude Code and run:

/plugin marketplace add obra/superpowers-marketplace

Step 2: Install Superpowers

/plugin install superpowers@superpowers-marketplace

Step 3: Restart Claude Code

Quit and relaunch Claude Code. Superpowers loads automatically on startup.

Global Installation (Recommended)

If you want Superpowers active in every project without per-project setup, install globally:

/plugin install superpowers@superpowers-marketplace --global

This is the recommended approach for most developers. You get the structured brainstorm-plan-execute workflow everywhere, and you can always skip it for quick one-off tasks by telling Claude to work without the Superpowers methodology.

Verify Installation

After restarting, you should see Superpowers skills loaded in your Claude Code session. Try running:

brainstorm a simple REST API for a todo app

If Claude starts by asking clarifying questions about your requirements instead of immediately writing code, Superpowers is working.

Practical Workflow Examples

Let us walk through three real scenarios that showcase the v5.0 improvements.

Example 1: Building a Dashboard UI

The Ask: “Build a React dashboard that shows real-time metrics from our API.”

Without Superpowers: Claude immediately starts writing React components. It guesses at the layout. It picks a charting library without asking. It builds something that works but looks nothing like what you had in mind.

With Superpowers 5:

1. Brainstorm phase — Claude asks about data sources, update frequency, target users, and layout preferences
2. Visual brainstorming — Claude generates an HTML mockup of the dashboard layout and opens it in your browser. You see the proposed grid, chart placements, and navigation
3. You iterate — “Move the alerts panel to the top. Make the main chart wider.” Claude regenerates the mockup
4. Spec phase — Claude writes a detailed specification based on the approved mockup
5. Spec review — A subagent checks the spec for completeness (did we specify responsive behavior? loading states? error states?)
6. Plan phase — Claude breaks the work into implementable tasks
7. Implementation — Haiku subagents build each component according to the plan
8. Code review — A dedicated reviewer checks each component against the spec
9. Finalization — You get tested, reviewed code that matches the mockup you approved

Example 2: Refactoring a Legacy Module

The Ask: “Refactor our authentication module to support OAuth 2.0 alongside our existing session-based auth.”

With Superpowers 5:

1. Claude reads the existing auth code and brainstorms the refactoring approach
2. The spec review agent flags that the plan does not address token refresh flows or session migration for existing users
3. The plan gets updated before any code is written
4. TDD kicks in: tests are written first for both auth strategies
5. Haiku subagents implement the refactoring according to the plan
6. The code reviewer catches a race condition in the token refresh logic
7. Final output: working OAuth 2.0 support with full test coverage and zero disruption to existing sessions

Example 3: Multi-Service Architecture

The Ask: “Design and implement a microservice that handles payment processing with Stripe.”

This is where Superpowers 5 really shines. The visual brainstorming generates a service architecture diagram showing the payment service, webhook handler, retry queue, and database schema. The spec review catches that the plan does not account for idempotency keys. And the Haiku subagents handle the bulk of the implementation while Sonnet manages the architecture decisions.

Reports from the community indicate Claude working autonomously for over two hours on projects like this without deviating from the approved plan, something that would be unthinkable with vanilla Claude Code.

Superpowers vs. Vanilla Claude Code

Let us be direct about when you should and should not use Superpowers.

Dimension	Vanilla Claude Code	Superpowers 5
Speed to first output	Fast — code appears immediately	Slower — brainstorming and planning come first
Output quality	Variable — depends on prompt quality	Consistently high — methodology enforces standards
Test coverage	Often skipped unless requested	85-95% — TDD is mandatory, not optional
Cost per session	Lower for simple tasks	Lower for complex tasks (Haiku subagents)
Planning quality	Minimal unless explicitly prompted	Thorough — spec review catches gaps
Best for	Quick scripts, one-file changes, exploration	Multi-file features, refactors, production code
Worst for	Already has overhead for trivial tasks	Five-line bug fixes that do not need a spec

The honest assessment: if you are writing a quick script or making a small config change, Superpowers adds unnecessary overhead. But the moment your task involves more than one file, requires tests, or needs to integrate with existing code, Superpowers produces dramatically better results.

The chardet library’s v7.0.0 release on March 4, 2026, is the best proof point. Built entirely using the Superpowers methodology, it delivered 41x faster performance and 96.8% accuracy while fixing dozens of longstanding issues. That is not a toy demo. That is a production library used by millions.

Power User Tips

After a week of heavy usage, here are the tricks that made the biggest difference for us.

1. Front-Load Your Context

Superpowers’ brainstorming phase works best when you give it real constraints upfront. Instead of “build a dashboard,” say “build a React 19 dashboard using Recharts, deployed on Vercel, hitting our REST API at /api/metrics, used by non-technical ops staff.” The more context you provide, the fewer clarifying questions Claude needs to ask, and the better the spec will be.

2. Use Global Install with Per-Project Overrides

Install Superpowers globally so it is always available, but keep project-specific CLAUDE.md files that customize the behavior. Superpowers reads your project instructions and adapts its methodology accordingly.

3. Do Not Fight the Process on Big Tasks

When you are building something substantial, resist the urge to skip brainstorming. The ten minutes spent in the planning phase consistently saves hours in the implementation phase. Trust the spec review. Let it catch your blind spots.

4. Review the Visual Brainstorming Output Carefully

The HTML mockups are your chance to course-correct before any code is written. Take the time to click through them, check edge cases, and provide specific feedback. Every minute spent refining the mockup saves ten minutes in code review.

5. Monitor Haiku Subagent Output

While Haiku handles implementation well with detailed plans, it occasionally misses nuance in complex logic. Keep an eye on the code review stage and do not hesitate to reject implementations that do not meet your standards. The two-stage review catches most issues, but your domain expertise catches the rest.

6. Combine with CLAUDE.md Project Instructions

Your project’s CLAUDE.md file and Superpowers work together. Use CLAUDE.md to set project-specific conventions (naming, file structure, preferred libraries) and let Superpowers handle the methodology. They complement each other perfectly.

FAQ

What is Superpowers for Claude Code and why does it have 82,000 GitHub stars?

Superpowers is an open-source agentic skills framework created by Jesse Vincent that adds a structured software development methodology to Claude Code. It enforces a brainstorm-spec-plan-TDD-implement-review pipeline that prevents Claude from skipping planning and testing. It has 82,000 GitHub stars because developers consistently report dramatically better output quality, with test coverage jumping to 85-95% and production libraries like chardet v7.0.0 achieving 41x performance improvements using the methodology. The framework is free, MIT-licensed, and works across multiple AI coding agents.

How do I install Superpowers 5 in Claude Code?

Run two commands in Claude Code: first /plugin marketplace add obra/superpowers-marketplace to add the marketplace, then /plugin install superpowers@superpowers-marketplace to install the plugin. Add the --global flag to the install command if you want it active in all projects. Restart Claude Code after installation. The entire process takes about ninety seconds.

What is visual brainstorming in Superpowers 5 and how does it work?

Visual brainstorming is a new feature in Superpowers 5 that replaces ASCII art diagrams with full HTML mockups rendered in your browser. When a design conversation goes beyond what terminal-based ASCII can handle, Claude generates an HTML file and opens it in your default browser so you can see actual layouts, architecture diagrams, and UI mockups with proper rendering. This makes the brainstorming phase more accurate and reduces misunderstandings before any code is written.

Does Superpowers cost money and does it work with other AI coding tools?

Superpowers is completely free and open-source under the MIT license. There are no hidden costs, subscriptions, or usage limits. While it was originally built for Claude Code, Superpowers now works across multiple platforms including Cursor, Codex, OpenCode, and Gemini CLI. It was officially accepted into the Anthropic plugin marketplace in January 2026.

When should I use Superpowers versus vanilla Claude Code?

Use Superpowers for any task that involves multiple files, requires tests, or needs to integrate with existing code. The structured methodology shines on medium-to-large projects where planning prevents costly mistakes. Use vanilla Claude Code for quick scripts, single-file changes, and exploratory coding where the overhead of brainstorming and spec review is not justified. The break-even point is roughly any task that would take more than fifteen minutes to implement manually.

Ready to turn Claude Code into a senior development partner? Install Superpowers 5 from the official marketplace and start your first structured brainstorming session today. Your future self, the one who is not debugging code that skipped the planning phase, will thank you.

Try Superpowers 5 for Claude Code — Free on GitHub