How to Use Claude Superpowers for Coding Tasks

Claude Superpowers is a community-built workflow extension that brings structured planning, step-by-step implementation and automated review into a single Claude session. It works by supplying a set of pre-defined slash commands or prompt templates that guide Claude through larger coding tasks in repeatable phases. Tools like fenbs keep the shared task plan and session results outside the model, so the next assistant picks up exactly where you left off.

The value is in the structure. Without it, a long coding session can drift: Claude implements something you did not quite plan, reviews its own work optimistically, or forgets the constraints you mentioned earlier. Superpowers breaks that loop by making each phase explicit and reviewable.

What Claude Superpowers adds to your workflow

A standard Claude session handles requests as they come. Superpowers adds three distinct phases: a planning phase that produces a reviewable task list before any code is written, an implementation phase that works through that list one item at a time, and a review phase that checks the result against the original plan.

Each phase produces output you can inspect and correct before moving to the next. That makes it easier to catch a misunderstanding early, when only a plan needs updating, rather than after several hundred lines of code have been written.

The workflow also suits the agent harness pattern: bounded tasks, explicit checkpoints, and verification before continuation. For a broader introduction to setting up Claude Code, see what Claude Code is.

How to find and install the Superpowers workflow

Claude Superpowers is distributed as a community project, so the installation method depends on the specific version you are using. Check the project's own documentation for the current setup instructions. The general steps are consistent across versions.

• Find the project's repository or distribution page and read the installation section.
• Copy or link the prompt templates into your Claude Code configuration, typically as entries in CLAUDE.md or as slash command definitions.
• Verify that each command appears in your command list before starting a real task.
• Run a small test task to confirm the phases work as expected in your environment.

If an installation step fails, read the error message before trying again. A missing dependency or a permissions issue will repeat until you address the underlying cause.

Running the planning phase

Before invoking the planning command, prepare a clear problem statement. Include the goal, the constraints (language version, existing APIs, file scope), and any rules that should not be broken. A vague request produces a vague plan, and a vague plan is hard to review.

When the plan appears, read it as a colleague's proposal, not as instructions you must follow. Check whether each step is scoped correctly and whether any step assumes access to something the plan does not mention. Correct the plan before you move on. A ten-minute review here saves an hour of untangling later.

Save the approved plan and its constraints in your shared task record. fenbs keeps Decisions and rules separate from the task list, so the next assistant knows both what to do and what it must not change.

Working through the implementation phase

The implementation command works through the plan one item at a time. After each item, verify the change before invoking the next step. Check that the code does what the plan said, not just that it runs without errors.

If a step produces something unexpected, stop and correct the plan rather than continuing. A corrected plan keeps the remaining steps aligned with what you actually want. Continuing with a drifted plan usually means undoing more work later.

Using the review phase effectively

The review phase checks the implementation against the plan. Read its output as a list of questions to investigate, not as a complete audit. Claude Superpowers can identify structural issues well, but it cannot verify behavior it has not tested.

For each finding the review raises, decide whether it is a real defect or a false positive. Record the real ones as tasks. If the same class of issue appears more than once, record it as a lesson so future sessions know to check for it. See the note on Claude Code memory for how memory carries between sessions.

When Claude Superpowers is not the right fit

Superpowers adds overhead. For a small, well-defined change in a familiar codebase, the three-phase structure may slow you down without adding precision. It is most useful when the task is large enough that an unreviewed plan could lead you to build the wrong thing.

It is also not a substitute for tests or human review. Use it to structure the session; use your normal verification process to confirm the result.

How to do this with fenbs

1. Create a free account and add the project. Write the goal, the language constraints and any standing rules as Decisions and rules. These appear first when a connected assistant reads the context.
2. Add a task for the feature or fix you are about to work on. Set its plan to the Superpowers-generated plan after you have reviewed and approved it.
3. Connect Claude Code over MCP from Integrations and ask it to read the project context before starting. The rules and task plan are available without re-pasting them into the chat.
4. After the implementation and review phases, update the task: mark what was completed, what the review found, and what still needs a manual check.
5. Save progress before the session ends. The next assistant reads Where we left off and continues from the current task state rather than starting from scratch.

For a related guide on the Claude-Code-specific extension pattern, see claude-code-superpowers, which covers the Code-specific commands in detail.