Choosing and Matching Superpowers Skills Effectively in Real-World Development

Core Selection Principles

Anchor base skills to the development stage – Superpowers automatically triggers stage‑specific skills following the native workflow; manual addition is reserved for complex, high‑risk, or custom scenarios.

Tighten constraints by code risk level – Core business, payment, authentication, middleware logic must bind test-driven-development, requesting-code-review, and verification-before-completion. Tooling, configuration, edge scripts may simplify the flow.

Pick execution‑scheduling skills based on task coupling – Strong dependencies or serial flows use executing-plans / subagent-driven-development; fully decoupled parallel tasks use dispatching-parallel-agents.

Match specialized skills to problem type – New requirements use design‑related skills, bug investigation uses debugging skills, code merges use branch‑finalization skills.

Scenario‑Based Skill Sets

1. Requirement Analysis & Design

Applicable phases : fuzzy requirements, architecture selection, module design, transformation evaluation. brainstorming – mandatory for all custom or vague requirements. writing-plans – optional supplement for detailed planning.

Example: Migrating a local cache to Redis – start with brainstorming to research eviction, serialization, expiration, clustering, and downgrade strategies; after confirming the plan, enable writing-plans to break down migration tasks.

2. New Feature Development

Standard combo (generic) : brainstorming → using-git-worktrees → writing-plans.

Small, simple functions (step‑by‑step manual checkpoints) use executing-plans.

Medium‑to‑large features (long processes, low intervention) use subagent-driven-development combined with test-driven-development, requesting-code-review, and verification-before-completion. Selection logic: if code changes are few and files are single, prefer executing-plans; if multiple files/classes/interfaces interact, prefer subagent-driven-development.

Example: Building a JWT authentication module – select brainstorming + using-git-worktrees + writing-plans + subagent-driven-development + TDD + double‑review verification.

3. Bulk Tool / Common Component Development

Core: brainstorming + writing-plans.

Scheduling core: dispatching-parallel-agents.

Quality fallback: test-driven-development + requesting-code-review.

Logic: when tasks are independent and non‑calling, enable parallel agents to shorten batch coding cycles.

4. Bug Fixing & Issue Investigation

systematic-debugging

– the only designated debugging skill for all exceptions, errors, or unexpected behavior. using-git-worktrees – required for hot‑fix isolation. test-driven-development – adds regression test cases. verification-before-completion – validates the fix.

Example: Kafka consumer duplicate consumption – use using-git-worktrees + systematic-debugging to locate the root cause, then TDD to create reproducible test cases and perform regression verification.

5. Code Refactoring & Legacy System Upgrade

Core combo: brainstorming (define refactor boundaries) + test-driven-development (lock existing behavior) + systematic-debugging (solve compatibility issues) + requesting-code-review. TDD is emphasized as the highest priority to guarantee business logic unchanged.

6. Code Review & MR/PR Remediation

receiving-code-review

– dedicated for handling external review feedback.

Supplement with test-driven-development for logic changes and verification-before-completion for regression checks.

7. Branch Management & Delivery Closure

Unique closing skill: finishing-a-development-branch – activate only after all coding, testing, and review are completed.

8. Team Customization & Private Rule Extension

Special skill: writing-skills – used only when customizing Superpowers, modifying built‑in rules, or adding team‑level checks; not needed for routine development.

Quick Decision Guide

Fuzzy requirement / architecture design – Core: brainstorming; Backup: writing-plans.

Serial small‑function development – Core: executing-plans; Backup: test-driven-development, requesting-code-review.

Large complex feature – Core: subagent-driven-development; Backup: using-git-worktrees, verification-before-completion.

Batch independent components – Core: dispatching-parallel-agents; Backup: test-driven-development, parallel task splitting.

Bug / exception / online issue – Core: systematic-debugging; Backup: using-git-worktrees, verification-before-completion.

Code refactor / logic optimization – Core: test-driven-development; Backup: systematic-debugging.

PR review feedback remediation – Core: receiving-code-review; Backup: verification-before-completion.

Development delivery & branch merge – Core: finishing-a-development-branch; Backup: full‑suite testing.

Common Pitfalls

Over‑enabling parallel agents – using dispatching-parallel-agents on dependent or strongly ordered tasks leads to context loss and logic errors.

Skipping brainstorming – starting coding without clarified requirements amplifies AI‑generated assumptions and causes rework.

Not using systematic‑debugging for bugs – surface hot‑fixes fail to eliminate root causes, resulting in recurring issues.

Omitting TDD in refactor scenarios – refactoring without test safety easily introduces hidden business logic changes.

Prematurely executing closing skill – invoking finishing-a-development-branch before completing tests and reviews contaminates the main branch with dirty code.

Conclusion

Routine business development relies on Superpowers’ native automatic trigger chain without manual skill activation.

Adopt a five‑stage “design → development → debugging → review → delivery” segmentation, enabling only the skills relevant to each stage.

High‑risk code must bind test-driven-development, requesting-code-review, and verification-before-completion constraints.

Task shape dictates scheduling strategy: serial tasks use executing-plans or subagent-driven-development; decoupled parallel tasks use dispatching-parallel-agents.

Match specialized problems with dedicated skills: debugging uses systematic-debugging, review remediation uses receiving-code-review, and branch closure uses finishing-a-development-branch.