# superpowers for Claude Code: what it does and how to install it

> The superpowers Flow bundles Jesse Vincent’s superpowers skills with a FLOW.md router and a hook. Install the Flowy engine once, activate the Flow, then prompt normally: a feature request routes to brainstorming and planning, a bug routes to systematic debugging, and a done claim routes to verification before it is spoken.

Canonical: https://www.flowy.sh/plugins/superpowers-flow/guide
Published: 2026-07-24
Updated: 2026-10-29
Author: Maximo Correa

## When does superpowers pay off?

You type "let's build a rate limiter." You do not type "use brainstorming."

The router reads that intent and the brainstorming skill loads before any code
gets written. Later, when you say "the test is failing," the same router sends
you to systematic debugging instead of letting the agent guess at fixes. When
the agent is about to say "done," verification fires and you get command output
instead of an assurance.

That is the whole idea. You prompt normally. The right discipline shows up.

## What does superpowers include?

This Flow bundles Jesse Vincent's superpowers skills, a widely used open-source
library of agent-discipline skills, and adds the routing layer on top. The
skills cover the full development lifecycle:

- **brainstorming** turns an idea into an approved design before code exists
- **writing-plans** turns that design into checkboxed, bite-sized tasks
- **test-driven-development** writes the failing test first, every time
- **systematic-debugging** finds a root cause before proposing any fix
- **verification-before-completion** proves a claim with command output
- **requesting-code-review** and **receiving-code-review** close the loop
- **finishing-a-development-branch** handles the integration decision
- **using-git-worktrees** and **dispatching-parallel-agents** handle isolation
  and fan-out

Flowy does not replace that library. It routes it, and it credits the author.

## How do I install superpowers in Claude Code?

```
/plugin marketplace add flowy-sh/flowy-core
/plugin install flowy-core
/plugin install flowy-superpowers
/flowy-superpowers:activate
```

The first two lines add the marketplace and install the engine, once per machine.
The third installs this overlay, and the fourth activates it for your session.

## How does invocation work in superpowers?

This is the part no other directory ships: a runtime hook for skill routing.

**The router.** `FLOW.md` is a plain markdown file that maps intent to skill. A
new feature routes to brainstorming, then writing-plans, then TDD inside every
code task. A bug routes to systematic-debugging first. A "done" claim routes to
verification. You can read the whole router before you trust it; it is not a
black box.

**The hook.** Activation writes a small session state, and a hook re-injects the
routing contract as you work, so the routing decision gets made every turn
instead of once at the start. Continuity is the thing that decays without it.

**The gates.** Each phase has an exit condition. Planning is not finished until
the tasks are checkboxed. A fix is not finished until a command's output proves
it. The gates are what stop a phase from being skipped quietly.

**What it is not.** The hook is a context nudge, not a hard gate. It cannot
physically stop an agent from skipping a step. What it does is keep the contract
in front of the model every turn, which is what makes the difference in
practice. We would rather say that accurately than oversell it.

## What does a first session with superpowers look like?

1. Activate it: `/flowy-superpowers:activate`
2. Ask for something real: "add pagination to the results list."
3. Watch it route to brainstorming and produce a short design before touching
   code.
4. Approve the design. It routes to writing-plans and hands you checkboxed
   tasks.
5. Let it build. TDD fires inside each code task, so the failing test comes
   first and you see it fail.
6. When it claims done, verification fires and you get the actual command
   output.

## When should you skip superpowers?

If you want one skill for one job, install that skill directly and invoke it
yourself. This Flow is for the case where you want the whole development
discipline to hold across a long session, which is exactly where an unrouted
skill library tends to fall apart.

Sources: [obra/superpowers on GitHub](https://github.com/obra/superpowers), [obra/superpowers README](https://github.com/obra/superpowers#readme)

## Common questions

### Does the hook force Claude to use these skills?

No. The hook is a context nudge, not a hard gate. It re-injects the routing so the model sees it every turn, but it cannot stop the model producing an answer without invoking a skill. Enforcement is the discipline the routing makes easy, not a lock.

### What is a FLOW.md, exactly?

A plain markdown file that maps intent to skill. It lists the states you can be in, such as about to write code or about to claim something is done, and names the skill each one should invoke, with an exit condition for each.

### Do I need anything besides the Flow itself?

Two things. The Flowy engine, which supplies the hook and the activation command, and the upstream superpowers plugin, which supplies the skills. This overlay bundles neither. It installs the routing only, so the skills stay on their author releases.

## Related

- [The listing page](https://www.flowy.sh/listings/superpowers-flow): Install command, components and repository
- [Alternatives to this plugin](https://www.flowy.sh/alternatives/superpowers-flow): Peers in its category, ranked by stars
- [The Claude Code plugin marketplace](https://www.flowy.sh/marketplace/plugins): How plugins install, and every plugin in the index
- [mattpocock/skills for Claude Code: install and use](https://www.flowy.sh/plugins/matt-pocock-flow/guide): another plugin guide
- [facebook/react for Claude Code: install and use](https://www.flowy.sh/plugins/facebook-react/guide): another plugin guide