Plugin Ecosystem

superpowers

Core skills library for Claude Code — TDD, debugging, collaboration patterns, and proven development techniques.

New

Core skills library for Claude Code: TDD, debugging, collaboration patterns, and proven development techniques.

Source: superpowers-dev marketplace Version: 4.3.1 Author: Jesse Vincent

Key Commands

Command	Description	When to Use
`/brainstorm`	Collaborative design session exploring requirements and approaches before implementation	Starting any creative work — new features, components, or behavior changes
`/write-plan`	Create a detailed implementation plan with bite-sized tasks	When you have a spec or requirements and need to break them into steps
`/execute-plan`	Execute a plan in batches with review checkpoints	When you have a written plan ready to implement

Skill	When It Activates
brainstorming	Before any creative work — creating features, building components, adding functionality
writing-plans	When you have a spec or requirements for a multi-step task, before touching code
executing-plans	When you have a written implementation plan to execute with review checkpoints
systematic-debugging	When encountering any bug, test failure, or unexpected behavior, before proposing fixes
test-driven-development	When implementing any feature or bugfix, before writing implementation code
subagent-driven-development	When executing implementation plans with independent tasks in the current session
dispatching-parallel-agents	When parallel work is beneficial across independent tasks
verification-before-completion	Before marking any task as complete
requesting-code-review	When preparing code for review
receiving-code-review	When processing review feedback
finishing-a-development-branch	When wrapping up work on a feature branch
using-git-worktrees	When working with git worktrees for isolated development
using-superpowers	General guidance on using superpowers effectively
writing-skills	When authoring new Claude Code skills

Agent	Purpose
code-reviewer	Reviews code after completing a plan step, checking for quality and correctness

This is the most common superpowers workflow, taking a feature from concept to code:

Brainstorm — Start with /brainstorm and describe your idea. Claude explores requirements, asks clarifying questions, considers approaches, and produces a design document.
Plan — Take the design output and run /write-plan. This produces a step-by-step implementation plan with bite-sized tasks, file paths, and TDD steps.
Execute — Run /execute-plan to implement the plan. Claude works through each task using subagents, with code review checkpoints between steps. The TDD skill ensures tests are written before implementation.

When something breaks, superpowers provides a structured debugging approach:

Debug — The systematic-debugging skill activates automatically when you describe a bug or test failure. Claude forms hypotheses, isolates the issue, and identifies the root cause before proposing any fix.
Fix with TDD — Once the root cause is found, the TDD skill kicks in: write a failing test that reproduces the bug, then implement the fix, then verify all tests pass.
Verify — The verification-before-completion skill ensures nothing is marked done until all checks pass.

Always start with /brainstorm before jumping to implementation. It often reveals requirements you had not considered.
The /write-plan output is designed to be consumed by /execute-plan. Keep them together in a workflow.
The code-reviewer agent runs automatically between plan steps. Do not skip its feedback.
For large features, the subagent-driven-development skill dispatches parallel agents to work on independent tasks simultaneously.