# Superpowers: Stop the Agent Before It Starts Coding

Date: 2026-10-19

The default behavior of a coding agent given a feature request is to start coding. Superpowers is a methodology that makes stopping and asking the first mandatory step. It is a plugin maintained by Prime Radiant that installs across Claude Code, Codex, Cursor, and most other major coding agents—and the skills trigger automatically.

<!--more-->

## Clarification before code

When a developer describes something to build, the `brainstorming` skill activates. It classifies the request into one of three paths before any code is touched.

A **spike**—a feasibility question—gets a two-sentence probe, a nod, and the cheapest investigation that answers the question. Output is a recommendation, not kept code. A **bounded** change to existing code gets a short in-chat design and stops; implementation starts only after explicit approval. An **architectural** request—new systems, subsystems, or changes to component interfaces—gets clarifying questions, two or three proposed approaches, a written spec, and a user review gate before any plan exists.

The ratchet is one-way: "When in doubt between two paths, take the heavier one." Hidden complexity discovered mid-task upgrades the path—the agent stops and says so.

## Human approval at each gate

The skill is explicit: "A reply approves the stage actually presented. Approval of an idea or feature scope does not approve artifacts that do not exist yet." Approving a description of a feature does not approve the design. Approving the design does not approve the plan. Each gate requires the actual artifact.

## The billing example, before the first line of code

A developer asks the agent to add subscription billing with cancellation and retry behavior. Before the brainstorming session closes, the design tree surfaces what the implementation cannot resolve by guessing: What counts as a failed payment? How many retries, at what interval? Does cancellation take effect immediately or at period end? What happens to already-paid months? Does a successful retry reset the billing date?

Each is a decision that, left unresolved, will be made silently by the agent. The brainstorming session exists to surface them before code exists.

## Small tasks, tested first

After the design is approved, the `writing-plans` skill produces an implementation plan broken into tasks with exact file paths, function signatures, and test commands.

The `test-driven-development` skill enforces TDD—red-green-refactor—within each task. Write a failing test, implement the minimal code to make it pass, then clean up while tests remain green. The skill states this as a hard rule: "NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST." Writing code before a test, then adding a test after, is a red flag requiring a restart.

## Execution and review

Implementation runs in one of two modes, chosen by the developer after reviewing the plan. **Subagent-driven**: a fresh sub-agent implements each task, a fresh reviewer checks it before the next task starts, then a whole-branch review at the end—most thorough, at higher token cost. **Inline**: one context executes all tasks, one final reviewer checks the branch—faster and cheaper, with less isolation between tasks.


## Compared with Matt Pocock Skills

Both enforce design before code, TDD within implementation, and structured review. The difference is composition. Matt Pocock Skills are individually invoked—the developer chooses which and when. Superpowers skills trigger automatically. The README describes them as "mandatory workflows, not suggestions."

## The trade-off

The full architectural path—classification, clarification, approaches, written spec, user review, implementation plan, user review, subagent-per-task execution, per-task review, final branch review—consumes time and tokens. A spike produces none of that overhead. A small bounded change needs only a short chat design.

The skill classifies and announces; the developer can override.

## Human control

The human approves the design before the plan is written and reviews the plan before execution begins. Destructive actions, security-sensitive operations, and external side effects require a human decision. Autonomous execution operates within an approved scope.

## What this is

This is software-delivery infrastructure for teams building production software. A developer shipping a billing feature needs requirements clarity, test coverage, and review against a spec. A business user asking an agent to draft a summary email does not. The methodology is built for one context, not the other.

---

*Source: github.com/obra/superpowers — SKILL.md files for brainstorming, writing-plans, test-driven-development, and subagent-driven-development. Retrieved 8 October 2026.*

#SoftwareEngineering #AgentSkills #DeveloperTools