Using Superpowers Expert

A meta-skill for maximizing Claude Code's capabilities by effectively combining skills, tools, and agent workflows. Covers skill discovery, composition patterns, subagent delegation, and strategies for tackling complex multi-step tasks.

When to Use This Skill

Choose this skill when:

• Tackling complex tasks that could benefit from multiple skills working together
• Learning which Claude Code capabilities are available for your task
• Orchestrating multi-step workflows across different tools and skills
• Delegating subtasks to specialized subagents for parallel execution
• Optimizing how you interact with Claude Code for maximum productivity

Consider alternatives when:

• Need a specific skill → invoke that skill directly
• Working on a simple, single-step task → use basic tools directly
• Setting up Claude Code configuration → use settings or preferences
• Learning about Claude Code features → read the documentation

Quick Start

Copy
# Superpower Discovery Checklist

## Before starting any task, consider:
1. Is there a skill that handles this exact task type?
2. Can the task be broken into subtasks for parallel execution?
3. Should I use plan mode for complex, multi-step implementations?
4. Are there project-specific skills in .claude/skills/?
5. Can I compose multiple skills for a better result?

## Tool Selection Priority
1. Dedicated tool (Read, Edit, Grep, Glob) → fastest, most reliable
2. Skill invocation → specialized knowledge and workflows
3. Subagent delegation → parallel research and exploration
4. Bash commands → system operations, builds, deployments
5. Web search → external information and documentation

Core Concepts

Capability Categories

Category	Capabilities	When to Use
Code Analysis	Read, Grep, Glob, Explore agent	Understanding codebases
Code Modification	Edit, Write	Making targeted changes
Research	Web search, Web fetch, Explore agent	Finding information
Planning	Plan mode, Todo list	Complex implementations
Execution	Bash, skill invocation	Running commands and workflows
Generation	Image gen, audio gen	Creating media assets
Delegation	Task tool with subagents	Parallel independent work

Multi-Skill Composition

Copy
# Example: Full Feature Implementation

## Step 1: Research (Explore agent)
- Understand existing architecture
- Find related code patterns
- Identify files that need changes

## Step 2: Plan (Plan mode)
- Design the implementation approach
- List all files to create/modify
- Define testing strategy

## Step 3: Implement (Edit/Write tools)
- Create new files
- Modify existing code
- Follow project conventions

## Step 4: Test (Bash + testing skill)
- Run test suite
- Fix failures
- Verify coverage

## Step 5: Review (Code review skill)
- Self-review the changes
- Check for security issues
- Verify completeness

Parallel Execution Patterns

Copy
# Independent tasks → run in parallel with Task tool

# Example: Research three topics simultaneously
Task 1: "Explore how authentication works in this codebase"
Task 2: "Find all API endpoints that need rate limiting"
Task 3: "Search for existing test utilities and helpers"

# All three run concurrently, results arrive when each finishes
# Then synthesize findings and proceed with implementation

Configuration

Parameter	Type	Default	Description
skillAutoDetect	boolean	true	Auto-detect applicable skills for tasks
parallelAgents	number	3	Max concurrent subagent tasks
planModeThreshold	string	'3+ files'	When to suggest plan mode
toolPreference	string	'dedicated'	Prefer dedicated tools over Bash
researchDepth	string	'thorough'	Research: quick, standard, or thorough
verifyResults	boolean	true	Verify outputs match expectations

Best Practices

1. Use dedicated tools before falling back to Bash — Read for files, Grep for searching, Edit for changes. Dedicated tools are faster, safer, and more transparent to review than equivalent Bash commands.

2. Delegate independent research to subagents — When you need to investigate multiple areas of a codebase, launch parallel Explore agents rather than researching sequentially. This saves significant time on large codebases.

3. Enter plan mode for changes touching more than 3 files — Planning catches architectural mistakes early. A plan reviewed and approved by the user prevents wasted effort from wrong assumptions about approach or scope.

4. Check for applicable skills before starting any task — Skills provide specialized knowledge and tested workflows. A task done with the right skill produces better results faster than ad-hoc approaches.

5. Break complex tasks into independent subtasks — Identify which parts of a task can proceed independently. Research, implementation, and testing for independent features can happen in parallel, dramatically reducing total time.

Common Issues

Wrong skill detected for the task — If automatic skill detection picks the wrong skill, specify the skill explicitly. Check .claude/skills/ for project-specific skills that might be more appropriate.

Subagent results too verbose or unfocused — Provide specific, focused prompts when launching subagents. Instead of "explore the codebase," use "find all files that handle user authentication and list the key functions in each."

Plan mode feels slow for simple tasks — Skip plan mode for straightforward changes (bug fixes, config updates, single-file additions). Use it only when the implementation approach is genuinely uncertain or affects multiple components.