A Complete Guide to Superpowers Skills with Scenario‑Based Usage Patterns

1. Official Core Skills Overview

brainstorming : Triggered automatically before any coding when a new requirement or ambiguous feature description appears; also supports manual invocation. Applicable to fuzzy requirement decomposition, architecture selection, legacy system boundary analysis, and collaborative assumption alignment. Executes a Socratic Q&A to produce technical constraints, design alternatives with pros/cons, and a standardized requirement specification.

dispatching-parallel-agents : Auto‑triggered when a task list contains multiple completely independent tasks (e.g., batch of uncoupled jobs, multi‑module builds, parallel test case generation). Assigns context‑isolated sub‑agents to each task, runs them concurrently, and outputs independent deliverables without context contamination.

executing-plans : Fires after a human‑approved implementation plan; also manual. Handles sequential tasks with dependencies, staged checkpoints, and step‑wise small‑scale feature rollout. Executes tasks in order, supports batch execution and pause‑for‑approval after each step, and records a reversible execution trace.

finishing-a-development-branch : Triggered automatically after all development tasks finish, full test suite passes, and code review is completed. Performs full regression testing, outputs branch change details, provides four standardized branch operations (merge, PR, retain, discard), and cleans up redundant files and environments.

receiving-code-review : Auto‑triggered on receiving human code‑review comments or PR feedback. Parses each comment, locates the affected code range, applies precise fixes without altering unrelated logic, and generates a standardized reply for every comment.

requesting-code-review : Fires after each independent development task before final branch cleanup. Performs automated review against the requirement spec, evaluating code for functional correctness, quality, security, and maintainability. Issues a problem list classified as block/critical/warning/suggestion and blocks further progress on block/critical issues.

subagent-driven-development : Triggered after plan confirmation when a batch of weakly dependent tasks needs execution. Allocates independent sub‑agents per atomic task, runs a double‑stage review (requirement compliance then code quality) before proceeding to the next task, supporting long‑running autonomous execution.

systematic-debugging : Auto‑triggered on runtime errors, test failures, or business exceptions. Follows the four‑phase "reproduce → isolate → fix → verify" workflow, builds minimal reproducible cases, pinpoints root causes, applies targeted fixes, and validates with automated verification cases.

test-driven-development : Mandatory auto‑trigger before any business code is written. Enforces the "red → green → refactor" loop: write a failing test, implement minimal code to pass, then refactor while keeping tests green. Prevents pre‑writing of code without tests.

using-git-worktrees : Triggered after brainstorming and design confirmation, before actual coding. Creates a Git worktree completely isolated from the main branch, initializes the environment, installs dependencies, and runs baseline verification, ensuring no code or environment overlap between parallel tasks.

using-superpowers : Fires on first installation, first‑time user query, or when users ask about Superpowers capabilities. Outputs a standardized usage guide, lists all skills, their trigger rules, and configuration methods, and helps troubleshoot trigger anomalies.

verification-before-completion : Auto‑trigger after each development task and before final branch cleanup. Validates functional completeness against the requirement spec, runs the full test suite covering normal, boundary, and error scenarios, and produces a verification report highlighting uncovered risks.

writing-plans : Triggered after requirement and design sign‑off. Breaks complex requirements into 2‑5‑minute atomic tasks, each with file path, implementation details, dependencies, and verification steps, forming a reviewable, adjustable, traceable implementation plan.

writing-skills : Auto‑triggered when users need to create or modify custom Superpowers skills. Generates a standardized specification, template, testing method, and compatibility requirements to ensure new skills work across all supported AI coding platforms.

2. Typical Scenario‑Based Skill Combinations

Scenario 1: Standard New‑Feature Full‑Process Development

Chain: brainstorming → using-git-worktrees → writing-plans → subagent-driven-development → requesting-code-review → verification-before-completion →

finishing-a-development-branch

brainstorming

: Define requirement boundaries, select architecture, assess risks, and produce a formal specification. using-git-worktrees: Create an isolated worktree and branch, initialize the environment, and run baseline tests. writing-plans: Decompose the design into atomic 2‑5‑minute tasks with explicit file paths and validation steps. subagent-driven-development: Assign each atomic task to an isolated sub‑agent; each sub‑agent runs test-driven-development internally and undergoes double‑stage review before moving to the next task. requesting-code-review: Perform automated review against the spec, output a graded problem list, and block progression on critical issues. verification-before-completion: Execute full test coverage, verify all functional requirements, and generate a verification report. finishing-a-development-branch: Run full regression, output change details, provide standardized merge/PR options, and clean up the worktree.

Scenario 2: Urgent Online Bug Fix

Chain: using-git-worktrees → systematic-debugging → test-driven-development → verification-before-completion → requesting-code-review → finishing-a-development-branch Create an isolated hot‑fix worktree.

Locate the root cause using the four‑phase debugging process.

Write a failing test that reproduces the bug, fix the code, and add defensive checks.

Run full regression to ensure no side effects.

Automated review validates security and functional compliance.

Finalize the hot‑fix branch and generate a PR template.

Scenario 3: Batch Parallel Development of Uncoupled Tasks

Chain: brainstorming → writing-plans → dispatching-parallel-agents → test-driven-development → requesting-code-review → verification-before-completion → finishing-a-development-branch Define boundaries and interfaces for each component.

Break each component into independent tasks.

Assign a sub‑agent to each task for parallel execution.

Enforce TDD for every sub‑agent.

Run automated review per component.

Validate each component with full tests.

Aggregate deliverables and close the branch.

Scenario 4: Bulk PR Review Remediation

Chain: receiving-code-review → test-driven-development → verification-before-completion → requesting-code-review → finishing-a-development-branch Parse each review comment and apply precise code fixes.

Add tests for the modified logic to guarantee verifiability.

Run a full regression suite to confirm no new regressions.

Re‑run automated review to ensure all comments are addressed.

Update the PR with a remediation summary and close the branch.

Scenario 5: Core Business Code Refactor

Chain: brainstorming → using-git-worktrees → writing-plans → test-driven-development → systematic-debugging → requesting-code-review → verification-before-completion → finishing-a-development-branch Define refactor scope, constraints, performance goals, and rollback plan.

Create an isolated refactor branch and worktree.

Decompose refactor into atomic steps with validation criteria.

Write comprehensive regression tests before any code change.

Apply four‑phase debugging to any failing tests during refactor.

Automated review checks adherence to the refactor plan and absence of business‑logic changes.

Run full regression, verify performance targets, and produce a verification report.

Output change details, generate PR content, and archive the branch.

Scenario 6: Multi‑Demand Parallel Development

Chain: brainstorming → using-git-worktrees → writing-plans → dispatching-parallel-agents → (per‑demand test-driven-development + requesting-code-review + verification-before-completion) → finishing-a-development-branch Perform boundary analysis and design for each independent demand.

Create separate isolated branches and worktrees per demand.

Break each demand into atomic tasks.

Dispatch independent sub‑agents to run tasks in parallel.

For each demand, execute TDD, automated review, and full verification.

Collect each demand’s deliverables, generate individual change logs and PR templates, and close all branches.

The guide demonstrates how Superpowers can orchestrate end‑to‑end software development, from requirement analysis to branch cleanup, by combining AI‑driven skills in a deterministic, reproducible manner.