Superpowers

Claude Code superpowers: core skills library for Git worktrees, test-driven development, systematic debugging, and workflow automation.

Overview

Superpowers is a comprehensive collection of specialized skills that supercharge Claude Code capabilities. Each skill addresses specific development workflows, from Git management to debugging strategies.

Core Skills

Using Git Worktrees

Isolate feature development with Git worktrees — clean separation, smart directory selection, safety verification.

• Create isolated worktrees for features
• Smart directory management
• Safety checks before operations
• Clean up when done

Best for: Parallel feature development, testing branches without main repo impact

Test-Driven Development

Implement features or bugfixes following TDD best practices — write tests first, ensure they fail, implement code, make tests pass.

• Test-first workflow guidance
• Red-Green-Refactor cycle
• Test design best practices
• Continuous validation

Best for: Feature implementation, bug fixes, ensuring code quality

Systematic Debugging

Encounter bugs? Systematic debugging provides structured debugging approach for errors, test failures, and unexpected behavior.

• 1-3 failed fix attempts trigger consultation
• Root cause analysis
• Log examination
• Step-by-step isolation

Best for: Complex bugs, performance issues, unexpected behavior

Executing Plans

Run written implementation plans in separate sessions with review checkpoints — break down tasks, track progress, verify each step.

• Task breakdown and estimation
• Progress tracking with checkpoints
• Independent task execution
• Verification at each step

Best for: Complex features, multi-step implementations, coordinated work

Finishing Development Branches

Implementation complete? Choose between merge, PR creation, or cleanup — analyze changes, run tests, update documentation.

• Completion verification
• Merge vs PR decision framework
• Test suite validation
• Documentation updates

Best for: Branch completion, integration, release preparation

Why Choose Superpowers

Battle-Tested Workflows

Each skill is based on real-world development challenges and proven solutions:

• Industry-standard Git practices
• TDD methodology from experts
• Debugging patterns from experienced engineers

Consistent Quality

All skills follow the same principles:

• Clear step-by-step guidance
• Safety checks and validations
• Evidence-based verification
• Recovery mechanisms

Developer-Focused

Designed for developers by developers:

• Addresses common pain points
• Reduces cognitive load
• Provides structured approaches
• Enables parallel work

Quick Start

Install Superpowers

1. Add the superpowers to your Claude configuration
2. Each skill is invoked automatically based on context
3. Skills are available as needed in your workflow

Using Git Worktrees Skill

User: "I need to fix a bug in production without affecting my current work"

Claude: Invoking using-git-worktrees skill...
→ Creates isolated worktree for bug fix
→ Sets up safety checks
→ Enables clean development

TDD Workflow

User: "I need to add a new feature to the payment system"

Claude: Invoking test-driven-development skill...
→ Guides test writing
→ Ensures tests fail initially
→ Implements feature
→ Confirms all tests pass

Use Cases

Parallel Feature Development

Use Git worktrees to:

• Work on multiple features simultaneously
• Isolate experimental changes
• Test production bugs without main repo interference
• Maintain clean main branch

Quality Assurance

Apply TDD for:

• Feature implementation
• Bug fixes
• Refactoring
• API development

Complex Debugging

Systematic debugging helps with:

• Intermittent issues
• Performance problems
• Integration failures
• Race conditions

Coordinated Development

Executing plans enables:

• Multi-developer coordination
• Task breakdown and assignment
• Progress tracking
• Milestone verification

Limitations

• Requires Git knowledge for worktrees
• TDD requires test suite familiarity
• Some skills need project context
• Debugging skill doesn't magically solve all problems

Technical Details

Skill Triggers

Skills are invoked automatically based on:

• User intent and context
• Task type (feature, bugfix, refactor)
• Current state (branch, errors, test failures)
• Number of failed attempts

Skill Composition

Skills can work together:

• Git worktrees + TDD for isolated feature development
• Debugging + executing plans for systematic problem solving
• Multiple skills can be active in one workflow

Verification Standards

Each skill includes verification:

• Evidence before claiming completion
• Automated checks where possible
• Manual verification steps
• Completion criteria

Deep Dive

Git Worktrees Architecture

• Directory management: Smart worktree naming and location
• Safety: Pre-operation checks, cleanup verification
• Branch awareness: Automatic branch tracking
• Integration: Works with existing Git workflows

TDD Implementation

• Test design: Arrange-Act-Assert patterns
• Red phase: Write failing tests first
• Green phase: Implement minimal code to pass
• Refactor phase: Improve without breaking tests

Debugging Strategy

• Information gathering: Logs, error messages, stack traces
• Hypothesis formation: Educated guesses about root cause
• Testing: Systematic validation of each hypothesis
• Recovery: Clear rollback points if fix fails

Best Practices

When to Use Each Skill

Git Worktrees: When you need isolation

• Working on multiple features
• Fixing production bugs
• Testing experimental changes

TDD: When code quality is critical

• New feature implementation
• Bug fixes
• Public API changes

Debugging: After 2+ failed attempts

• Complex issues
• Recurring problems
• Unclear root causes

Executing Plans: For multi-step work

• Complex features
• Coordinated team efforts
• Release preparation

Skill Combinations

• Git Worktrees + TDD: Isolated, test-driven development
• Debugging + Executing Plans: Systematic fix and verification
• Git Worktrees + Finishing: Clean feature completion workflow

Team Adoption

• Standardize on skill usage across team
• Document skill-based workflows
• Train team on skill triggers
• Review skill effectiveness retrospectively

Related Skills

• Git workflow tools
• Testing frameworks
• Debugging utilities
• Project management skills