Other Essential Skills

Relevant source files

• skills/dispatching-parallel-agents/SKILL.md
• skills/finishing-a-development-branch/SKILL.md
• skills/test-driven-development/SKILL.md
• skills/test-driven-development/testing-anti-patterns.md
• skills/using-git-worktrees/SKILL.md
• skills/verification-before-completion/SKILL.md

This page provides reference documentation for important skills beyond the four core skills covered in sections 7.1 through 7.4. These skills enable specific workflow phases (workspace setup, plan execution, completion) and advanced patterns (parallel agent dispatch, code review). For complete implementation details, prerequisites, and anti-rationalization guards, refer to the SKILL.md file for each skill.

For the complete development workflow overview, see 6.1. For detailed workflow steps, see sections 6.2 through 6.8. For creating your own skills, see 8.

Skill Categories and Workflow Position

The following diagram shows how these essential skills fit into the development lifecycle and which phases they support:

Sources: skills/using-git-worktrees/SKILL.md1-219 skills/writing-plans/SKILL.md1-117 skills/finishing-a-development-branch/SKILL.md1-201 skills/requesting-code-review/SKILL.md1-106

Workspace Management Skills

using-git-worktrees

Purpose: Creates isolated git worktrees with smart directory selection and safety verification before executing implementation plans.

When to use: Before starting any feature work that needs isolation, always before executing implementation plans, when working on multiple branches simultaneously.

Core mechanism:

1. Directory Selection Priority skills/using-git-worktrees/SKILL.md16-49:

   • Check for existing .worktrees/ or worktrees/ directories
   • Check CLAUDE.md for preferences
   • Ask user if no convention established

2. Safety Verification skills/using-git-worktrees/SKILL.md51-73:

   • Verify project-local directories are in .gitignore
   • Auto-fix by adding to .gitignore and committing if not ignored
   • Skip verification for global directories (~/.config/superpowers/worktrees/)

3. Automated Setup skills/using-git-worktrees/SKILL.md100-118:

   • Auto-detect project type (Node.js, Rust, Python, Go)
   • Run dependency installation (npm install, cargo build, etc.)
   • Verify clean test baseline before proceeding

Key integration points:

• Called by brainstorming skill at Phase 4 (mandatory when approved)
• Required before subagent-driven-development or executing-plans
• Paired with finishing-a-development-branch for cleanup

Project Type	Detection File	Setup Command
Node.js	package.json	npm install
Rust	Cargo.toml	cargo build
Python	requirements.txt or pyproject.toml	pip install -r requirements.txt or poetry install
Go	go.mod	go mod download

Sources: skills/using-git-worktrees/SKILL.md1-219

finishing-a-development-branch

Purpose: Guides completion of development work by presenting structured options for merge, PR, or cleanup after implementation is complete.

When to use: When all tasks complete, tests pass, and you need to decide how to integrate work back into main branch.

Core workflow skills/finishing-a-development-branch/SKILL.md18-150:

1. Verify Tests - Run project test suite, stop if failures detected
2. Determine Base Branch - Identify merge target (main/master)
3. Present Options - Exactly 4 structured choices
4. Execute Choice - Handle merge, PR creation, keep, or discard
5. Cleanup Worktree - Remove worktree for options 1, 2, 4 only

The Four Options:

Option	Action	Push Remote	Keep Worktree	Delete Branch
1. Merge locally	Merge to base, verify tests	No	No	Yes
2. Create PR	Push branch, open PR	Yes	Yes	No
3. Keep as-is	No action	No	Yes	No
4. Discard	Confirm, force delete	No	No	Yes (forced)

Safety mechanisms:

• Requires passing tests before presenting options
• Typed confirmation ("discard") for Option 4
• Verifies tests on merged result for Option 1
• Never auto-cleanup worktrees for PR workflow

Integration points:

• Called by subagent-driven-development after Step 7
• Called by executing-plans after Step 5
• Cleans up worktrees created by using-git-worktrees

Sources: skills/finishing-a-development-branch/SKILL.md1-201

Planning and Execution Skills

writing-plans

Purpose: Creates comprehensive implementation plans with bite-sized tasks assuming implementer has zero context about codebase.

When to use: After design is approved, before touching any code, when you have spec or requirements for multi-step task.

Task granularity principle skills/writing-plans/SKILL.md20-28: Each step is one action taking 2-5 minutes:

• "Write the failing test" - step
• "Run it to make sure it fails" - step
• "Implement the minimal code to make the test pass" - step
• "Run the tests and make sure they pass" - step
• "Commit" - step

Required plan structure skills/writing-plans/SKILL.md29-88:

Key characteristics:

• Exact file paths always included
• Complete code in plan (not "add validation")
• Exact commands with expected output
• References to relevant skills using @ syntax
• DRY, YAGNI, TDD, frequent commits emphasized

Execution handoff skills/writing-plans/SKILL.md97-117: Offers two execution strategies after saving plan.

Sources: skills/writing-plans/SKILL.md1-117

Execution Strategy Skills

The following diagram shows the relationship between execution strategy skills and the code entities they interact with:

Sources: skills/writing-plans/SKILL.md97-117 skills/requesting-code-review/SKILL.md76-90

subagent-driven-development

Purpose: Execute implementation plans using fresh subagent per task with two-stage review (spec compliance then code quality).

When to use:

• Same session as planning
• Tasks are independent (no shared state between tasks)
• Want automated quality gates
• Prefer fast iteration over human checkpoints

Core pattern:

1. Task Dispatch - Create fresh subagent for each task in plan
2. Implementation - Subagent implements using TDD 7.3
3. Self-Review - Subagent reviews own work
4. Spec Review - Dispatch superpowers:code-reviewer to verify requirements met
5. Quality Review - Dispatch second reviewer to check best practices
6. Iteration - Loop back if issues found
7. Next Task - Move to next task only when current passes both reviews

Key benefit: Fresh subagent per task prevents context contamination and accumulated biases from previous tasks.

Trade-offs:

Advantage	Disadvantage
Automated quality gates	Higher token usage (multiple subagents)
Fresh context per task	Cannot handle sequential dependencies
Catches issues immediately	Requires independent tasks
Fast iteration in single session	More complex orchestration

Integration points:

• Invoked by user after writing-plans offers execution choice
• Requires using-git-worktrees to have run first
• Calls requesting-code-review after each task
• Calls finishing-a-development-branch when all tasks complete

Sources: Referenced in skills/writing-plans/SKILL.md109-113 skills/requesting-code-review/SKILL.md76-83

executing-plans

Purpose: Execute implementation plans in separate session with batch execution and human review checkpoints.

When to use:

• Separate session from planning
• Tasks have sequential dependencies
• Want human oversight at regular intervals
• Prefer human checkpoints over automated review

Core pattern:

1. Batch Execution - Execute 3 tasks in sequence
2. Human Checkpoint - Present results, wait for feedback
3. Apply Changes - Incorporate human feedback
4. Next Batch - Continue if more tasks remain
5. Completion - Call finishing-a-development-branch when done

Key benefit: Human checkpoints catch issues that automated reviews miss, especially architectural concerns.

Trade-offs:

Advantage	Disadvantage
Human oversight	Requires human availability
Lower token usage	Slower iteration
Handles dependencies	Manual checkpoint management
Architectural feedback	Can introduce delays

Batch size rationale: 3 tasks provides balance between progress and review frequency. Too small causes excessive interruption, too large delays feedback.

Sources: Referenced in skills/writing-plans/SKILL.md114-117 skills/requesting-code-review/SKILL.md84-90

Quality Assurance Skills

requesting-code-review

Purpose: Dispatch superpowers:code-reviewer subagent to verify work meets requirements before cascading issues.

When to use:

• Mandatory: After each task in subagent-driven development
• Mandatory: After completing major feature
• Mandatory: Before merge to main
• Optional: When stuck (fresh perspective), before refactoring, after fixing complex bug

Invocation pattern skills/requesting-code-review/SKILL.md24-42:

Template placeholders:

• {WHAT_WAS_IMPLEMENTED} - What you just built
• {PLAN_OR_REQUIREMENTS} - What it should do
• {BASE_SHA} - Starting commit SHA
• {HEAD_SHA} - Ending commit SHA
• {DESCRIPTION} - Brief summary

Review output categories:

• Critical - Fix immediately, blocks progress
• Important - Fix before proceeding
• Minor - Note for later
• Strengths - What went well

Integration with workflows:

Sources: skills/requesting-code-review/SKILL.md1-106

verification-before-completion

Purpose: Ensures all verification steps complete before claiming task is done, prevents premature completion.

Core principle: Cannot claim "done" until all verification steps from plan are executed and pass.

Verification checklist:

1. All tests pass (unit, integration, end-to-end)
2. Manual verification steps from plan completed
3. No regressions in existing functionality
4. Documentation updated if needed
5. Commit messages follow conventions

Common mistakes prevented:

• Claiming done when tests haven't run
• Skipping manual verification steps
• Not checking for regressions
• Forgetting documentation updates

Integration point: Called implicitly at end of every task execution, explicitly before finishing-a-development-branch.

Sources: Referenced in skills/systematic-debugging/SKILL.md286-289

Advanced Patterns

dispatching-parallel-agents

Purpose: Dispatch multiple agents to investigate independent problems concurrently, parallelizing investigation work.

When to use skills/dispatching-parallel-agents/SKILL.md14-43:

Use when:

• 3+ test files failing with different root causes
• Multiple subsystems broken independently
• Each problem can be understood without context from others
• No shared state between investigations

Don't use when:

• Failures are related (fix one might fix others)
• Need to understand full system state
• Agents would interfere with each other

The pattern skills/dispatching-parallel-agents/SKILL.md45-80:

1. Identify Independent Domains - Group failures by what's broken
2. Create Focused Agent Tasks - Each gets specific scope, clear goal, constraints
3. Dispatch in Parallel - Use Task tool to launch all agents concurrently
4. Review and Integrate - Verify fixes don't conflict, run full test suite

Good agent prompt structure skills/dispatching-parallel-agents/SKILL.md82-108:

• Focused - One clear problem domain
• Self-contained - All context needed
• Specific output - What agent should return

Example:

Real-world impact skills/dispatching-parallel-agents/SKILL.md174-180:

• 6 failures across 3 files
• 3 agents dispatched in parallel
• All investigations completed concurrently
• Zero conflicts between agent changes
• Time: 3 problems solved in time of 1

Sources: skills/dispatching-parallel-agents/SKILL.md1-181

Skill Files and Discovery

The following diagram maps skill names to their filesystem locations and how they're discovered by the system:

Sources: skills/using-git-worktrees/SKILL.md1-4 skills/writing-plans/SKILL.md1-4 skills/finishing-a-development-branch/SKILL.md1-4 skills/requesting-code-review/SKILL.md1-4 skills/dispatching-parallel-agents/SKILL.md1-4

Quick Reference: When to Use Each Skill

Skill	Trigger Condition	Before Action	After Action
using-git-worktrees	Starting feature work	None	Worktree ready, tests passing
writing-plans	Have spec/requirements	Design approved	Plan saved to docs/plans/
subagent-driven-development	Executing plan (same session)	Plan exists, worktree ready	All tasks complete
executing-plans	Executing plan (separate session)	Plan exists, worktree ready	All batches complete
requesting-code-review	Completed task/feature	Code committed	Review feedback addressed
verification-before-completion	Claiming task done	Implementation complete	All checks pass
finishing-a-development-branch	All work complete	Tests passing	Branch merged/PR created
dispatching-parallel-agents	3+ independent failures	Problems identified	All fixes integrated

Sources: skills/using-git-worktrees/SKILL.md1-219 skills/writing-plans/SKILL.md1-117 skills/finishing-a-development-branch/SKILL.md1-201 skills/requesting-code-review/SKILL.md1-106 skills/dispatching-parallel-agents/SKILL.md1-181

Additional Skills

The following skills exist in the repository but are not covered in detail in this wiki:

Meta-skills:

• writing-skills - Creating new skills using TDD methodology (see 8.1)
• sharing-skills - Contributing skills back to community (see 8.6)

Supporting techniques for systematic-debugging:

• root-cause-tracing - Trace bugs backward through call stack skills/systematic-debugging/SKILL.md110-120
• defense-in-depth - Add validation at multiple layers skills/systematic-debugging/SKILL.md283
• condition-based-waiting - Replace timeouts with condition polling skills/systematic-debugging/SKILL.md284

For complete list of available skills, see the skills directory at ~/.config/superpowers/skills/ after installation.

Sources: skills/systematic-debugging/SKILL.md278-289