How to use superpowers in Claude Code

The moment it pays 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 is inside

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.

Install it

/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 invocation actually works

This is the part other directories cannot describe, because they stop at the install command.

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.

A first session, start to finish

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 you should not use it

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.