Run the Complete Superpowers Workflow: Design, TDD, Debugging, Review, and Finish

Quick answer

Superpowers is a third-party agentic development methodology delivered as composable skills. Its core flow is: clarify through brainstorming, approve a design, create an isolated worktree, write a granular plan, implement through red-green-refactor, debug systematically, review for specification and code quality, verify before completion, and deliberately finish the branch. Install only after reviewing its source and current instructions. The canonical workflow and commands are in the Superpowers repository.

Understand what the plugin changes

Superpowers adds workflow discipline, not a more capable base model. Its skills can trigger automatically and favor mandatory process: design before implementation, tests before production code, root-cause debugging, evidence before completion, and isolated parallel work. That structure improves many product changes but can be excessive for trivial edits or exploratory throwaway work.

Review the installed version, hooks, telemetry notes, skills, scripts, and supported Claude Code marketplace path before use. Do not copy installation commands from an old article without checking upstream.

Phase 1: brainstorm and approve design

Start with a bounded feature such as expiring share links. The brainstorming workflow should elicit users, lifecycle, authorization, error behavior, data model, alternatives, and non-goals. Approve the design in readable sections. If a product decision is unresolved, stop rather than smuggling an assumption into code.

Example request:

Design expiring, revocable share links for reports. Interview me about behavior and
security, inspect existing access-control patterns, present alternatives with tradeoffs,
and write the accepted design. Do not implement until I approve it.

Phase 2: isolate and plan

Create a Git worktree only after checking repository conventions and a clean baseline. The plan should break work into small tasks with exact files, behavior, tests, and verification. Small steps make review and recovery cheaper; they should still form coherent vertical slices rather than mechanical line edits.

Phase 3: red-green-refactor

For each behavior:

1. Write the smallest test that expresses it.
2. Run the test and observe the expected failure for the right reason.
3. Write minimal production code.
4. Run the test and observe a pass.
5. Refactor without changing behavior.
6. Run relevant broader checks.

If a test passes before production code changes, it does not prove the new behavior. Improve the test before continuing.

Phase 4: systematic debugging

When a step fails unexpectedly, stop layering fixes. Reproduce, gather evidence, trace the earliest incorrect state, form one hypothesis, and run a discriminating experiment. A retry or timeout increase is not a root cause unless evidence shows the system's intended contract was too strict.

Phase 5: two-dimensional review

First review spec compliance: did the implementation meet every accepted behavior and avoid non-goals? Then review code quality: correctness, security, maintainability, performance, and test robustness. Fix critical findings and rerun verification. A reviewer should cite concrete failure paths rather than preferences.

Phase 6: finish intentionally

Run the full required checks, inspect the diff and working tree, then choose merge, PR, retain, or discard according to repository policy. Do not push or open a PR unless authorized. Preserve verification evidence in the handoff.

Mastery lab

Implement expiring share links through the entire workflow. Track elapsed time, tests written first, defects found by spec review versus quality review, context use, and deviations. Repeat a smaller task without the plugin and compare outcomes rather than assuming process always wins.

FAQ

Does Superpowers replace Claude Code's built-in plan mode?

No. It layers a methodology and skills onto Claude Code features; the underlying tools and permissions still apply.

Must every change use TDD?

The plugin's philosophy strongly enforces TDD. Decide whether that methodology matches the task and team before installing or invoking it.

Can Superpowers run for hours unattended safely?

Duration does not create safety. Use isolated worktrees, constrained permissions, reliable tests, no external mutation authority, and review checkpoints.