Superpowers: The Free Plugin That's Quietly 10×ing Claude Code Output

There's a free Claude Code plugin that almost nobody outside a small community is talking about, and it's quietly turning Claude Code from "smart autocomplete with a tool loop" into "disciplined developer who actually does discovery before touching code." It's called Superpowers, it's open source, it's by Jesse Vincent, and it installs in about five seconds.

Nate Herk just ran a controlled 12-run experiment on it. The headline: 9% cost savings, 14% fewer total tokens, measurably better code quality on medium-complexity tasks — and most of the benefit comes from the plugin asking better questions before it writes a single line of code.

"The value isn't in the extra steps. It's in preventing expensive retries and backtracking."

What Superpowers actually is

A plugin you install through the Claude Code marketplace that adds 14 skills, organized into phases:

1. Clarify — interrogates your request until it's 95%+ confident
2. Design — brainstorms approaches, opens a visual companion in your browser to show you mock-ups
3. Plan — writes a hyper-detailed implementation plan (every task 2-5 minutes of work, exact file paths)
4. Code — executes task by task with safety stops, sub-agent dispatching, parallel agents where possible
5. Verify — TDD-style verification, systematic debugging

The master skill using superpowers fires at the start of every conversation and acts as a dispatcher — it decides which of the 14 skills to invoke based on what you're actually doing. You don't memorize any of this. Install once globally, forget it exists, watch your sessions get more disciplined.

The visual companion is the killer feature

The one thing Superpowers does that no other plugin currently does: it opens a localhost web UI showing 2-3 design approaches before it builds anything.

Nate's example — he asked Claude to build a knowledge explorer. Instead of just starting to code, Superpowers asked five clarifying questions, then opened a localhost browser tab showing three options: an interactive force graph, a searchable card grid, and a hybrid graph-plus-card-details design. Each came with pros and cons. He picked one in the browser, Claude saw the choice and continued building.

That's the loop most token waste comes from — Claude guessing wrong about what you wanted, building something close-but-off, and you having to redirect. Superpowers bakes the redirect into the planning phase, when it's cheap, not the execution phase, when it's expensive.

The 12-run experiment

Nate ran 6 sessions with Superpowers and 6 without, same prompts, Opus 4.6, zero human interaction. Tasks at three complexity levels:

Complexity	With Superpowers vs without
Simple	Slightly more expensive (~8% overhead) — discovery questions don't pay off on trivial tasks
Medium	Cheaper + faster + measurably better code quality
Complex	Significantly cheaper, lower variance, better outputs

Across all 12 runs: 9% lower average cost, 14% fewer total tokens, 2-3× lower variance in token usage. Variance is the underrated number here — without Superpowers, some runs blew through tokens; with Superpowers, they were tightly clustered. Predictability is half the value.

Code quality (evaluated on correctness, structure, test coverage, error handling) was measurably better with Superpowers on medium tasks. The only dimension where it didn't help: domain knowledge and spec compliance — that's still on the model itself, not the plugin.

When NOT to use it

Nate is honest about this and it matters:

• Simple tasks (one-line fixes, small refactors): skip Superpowers. The 8% overhead from clarification questions doesn't pay off, and the brainstorming phase adds friction you don't need.
• You want a fast prototype to throw away: the plugin's discipline becomes a tax.
• The request is genuinely well-specified in the prompt: Superpowers will still ask questions, and they might feel redundant.

The sweet spot: anything where Claude getting it wrong the first time is going to cost you a re-do.

How to install (literally one command)

From inside Claude Code:

/plugin

Search the marketplace for superpowers (by Jesse Vincent), and install it globally on the user level — not per-project. Once globally installed, every Claude Code project on your machine picks it up without re-installing.

Verify it's loaded:

/plugin

If you see superpowers listed, you're done. The next conversation you start will automatically pull in using superpowers as the dispatcher.

The Ultra Plan question

If you're already using Anthropic's new Ultra Plan (cloud-hosted multi-agent planning), Superpowers' brainstorming skill might feel redundant. Nate's read: "the Superpowers brainstorming might actually be better than Ultra Plan for the planning step" — because Ultra Plan ends when the plan does, while Superpowers is with you through the whole build phase.

The pragmatic stack:

• Use Superpowers for everything — it's free, set-and-forget, and helps from clarify through verify.
• Add Ultra Plan on top for the largest plans where you want a parallel-agent critique pass. The two compose; you don't have to pick.

The disciplined-developer analogy

The best frame for Superpowers is: what if Claude Code worked the way a senior engineer works? A senior engineer doesn't take your one-paragraph feature request and start coding. They ask five questions. They sketch the design. They write the test before the implementation. They stop and check when something feels wrong instead of plowing through.

That's what Superpowers installs. Not new capability. New discipline. Every skill in the plugin is something a great engineer already does — codified into a checklist that gets followed every session.

What to actually do this week

1. Install Superpowers globally on the user level. One minute of setup.
2. Run your next non-trivial Claude Code task with it on and pay attention to how the clarifying questions reshape the work.
3. Compare a session with Superpowers to your previous baseline — same kind of task, eyeball the token usage and the quality of output. The 14% number is the average; some workloads will see way more.
4. Keep it off for one-liners and prototypes where the discovery phase adds friction.

If the brainstorming visual companion works for you, share it with your team — the localhost mock-ups feature is the most underrated UX win in Claude Code tooling right now.

The Bottom Line

The Claude Code plugin ecosystem is going to fragment fast — Anthropic just shipped Managed Agents, the agent SDK is maturing, and dozens of community plugins are showing up. Most will be noise. Superpowers is the one that already deserves a permanent slot in your setup. Open source, zero cost, install in 5 seconds, payback by the third medium-complexity task. The fastest Claude Code upgrade you can make this week is the plugin Anthropic didn't ship — and didn't need to.