Command	Purpose	Key Options
`analyze`	Code quality, security, performance analysis	`--focus quality\|security\|performance\|architecture`, `--depth quick\|deep`
`build`	Build, compile, package projects	`--type dev\|prod\|test`, `--clean`, `--optimize`
`cleanup`	Remove dead code, optimize structure	`--type code\|imports\|files\|all`, `--safe\|--aggressive`, `--dry-run`
`design`	System architecture, API design	`--type system\|api\|component`, `--document`
`document`	Create documentation for components	`--type inline\|external\|api\|guide`, `--style brief\|detailed`
`estimate`	Time/effort/complexity estimates	`--format brief\|detailed`, `--include-risks`
`explain`	Explain code, concepts, behavior	`--depth overview\|detailed\|deep`, `--audience beginner\|intermediate\|expert`
`git`	Git operations with smart commits	`--smart-commit`, `--branch-strategy`
`implement`	Feature and code implementation	`--type component\|api\|service\|feature`, `--with-tests`, `--safe`
`improve`	Quality, performance improvements	`--focus quality\|performance\|security`, `--scope file\|module\|project`
`index`	Project documentation and knowledge base	`--type readme\|api\|structure`, `--format markdown\|json`
`load`	Load and analyze project context	`--scope files\|dependencies\|config\|all`
`spawn`	Break tasks into coordinated subtasks	`--sequential\|--parallel`, `--validate`
`task`	Workflow management with persistence	`--strategy systematic\|agile\|enterprise`, `--persist`, `--hierarchy`
`test`	Execute tests, generate reports	`--type unit\|integration\|e2e\|all`, `--coverage`, `--watch`
`troubleshoot`	Diagnose and resolve issues	`--type bug\|build\|performance\|deployment`, `--trace`, `--fix`
`workflow`	Generate implementation workflows	`--strategy systematic\|agile\|mvp`, `--output roadmap\|tasks\|detailed`

analyze

Analyze code quality, security, performance, and architecture.

When to use

Code quality or technical debt analysis
Security audit or vulnerability assessment
Performance bottleneck identification
Architecture review

Usage

/sc analyze [target] [--focus quality|security|performance|architecture] [--depth quick|deep]

Execution

Discover and categorize files
Apply analysis tools and techniques
Generate findings with severity ratings
Create actionable recommendations

build

Build, compile, and package projects.

When to use

Build or compile a project
Diagnose build errors
Production optimization

Usage

/sc build [target] [--type dev|prod|test] [--clean] [--optimize]

Execution

Analyze project structure and build config
Validate dependencies
Execute build with error monitoring
Optimize output and report results

cleanup

Clean up code, remove dead code, optimize structure.

When to use

Remove dead code or unused imports
Optimize project structure
Technical debt cleanup

Usage

/sc cleanup [target] [--type code|imports|files|all] [--safe|--aggressive] [--dry-run]

Execution

Analyze for cleanup opportunities
Identify dead code, unused imports
Create cleanup plan with risk assessment
Execute with safety measures
Validate and report results

design

Design system architecture, APIs, and component interfaces.

When to use

System or component architecture
API design
Interface planning

Usage

/sc design [target] [--type system|api|component] [--document]

Execution

Analyze requirements and constraints
Research patterns and best practices
Create architecture proposal
Document design decisions

document

Create focused documentation for components or features.

When to use

Code documentation
API documentation
User guides

Usage

/sc document [target] [--type inline|external|api|guide] [--style brief|detailed]

Execution

Analyze target component
Identify documentation requirements
Generate documentation
Apply consistent formatting

estimate

Provide development estimates for tasks.

When to use

Time estimates needed
Effort assessment
Project sizing

Usage

/sc estimate [task] [--format brief|detailed] [--include-risks]

Execution

Analyze task complexity
Identify dependencies and risks
Generate estimate with confidence levels
Document assumptions

explain

Provide clear explanations of code, concepts, or behavior.

When to use

Code explanation needed
Concept clarification
Behavior understanding

Usage

/sc explain [target] [--depth overview|detailed|deep] [--audience beginner|intermediate|expert]

Execution

Analyze target code/concept
Identify key components
Generate explanation at appropriate level
Include examples if helpful

git

Git operations with intelligent commit messages.

When to use

Commit with good messages
Branch management
Merge/rebase assistance

Usage

/sc git [operation] [--smart-commit] [--branch-strategy]

Execution

Analyze current Git state
Execute requested operations
Generate intelligent commit messages
Handle conflicts and provide feedback

implement

Feature and code implementation.

When to use

Implement features or components
New functionality
API or service implementation

Usage

/sc implement [feature] [--type component|api|service|feature] [--with-tests] [--safe]

Execution

Analyze requirements and detect context
Auto-activate relevant personas
Generate implementation with best practices
Apply security and quality validation
Provide testing recommendations

improve

Apply systematic improvements to code.

When to use

Refactoring code
Cleaning up technical debt
Optimizing performance

Usage

/sc improve [target] [--focus quality|performance|security] [--scope file|module|project]

Execution

Analyze current state
Identify improvement opportunities
Prioritize changes by impact
Apply improvements systematically
Validate results

index

Generate project documentation and knowledge base.

When to use

Create docs or README
API documentation
Project structure maps

Usage

/sc index [target] [--type readme|api|structure] [--format markdown|json]

Execution

Scan project structure
Extract key information
Generate documentation
Organize knowledge base

load

Load and analyze project context.

When to use

Starting work on a project
Understanding configurations
Analyzing dependencies

Usage

/sc load [target] [--scope files|dependencies|config|all]

Execution

Identify project structure
Load configurations
Analyze dependencies
Build context summary

spawn

Break complex tasks into coordinated subtasks.

When to use

Complex multi-step tasks
Parallel work orchestration
Dependency management

Usage

/sc spawn [task] [--sequential|--parallel] [--validate]

Execution

Parse request and create task breakdown
Map dependencies
Choose execution strategy
Execute with progress monitoring
Integrate and validate results

task

Execute tasks with workflow management and persistence.

When to use

Large project management
Cross-session progress tracking
Multi-phase operations

Usage

/sc task [action] [target] [--strategy systematic|agile|enterprise] [--persist] [--hierarchy]

Actions

create - Create task hierarchy
execute - Execute with orchestration
status - View task status
analytics - Performance dashboard
delegate - Multi-agent delegation

Strategies

systematic: Discovery → Planning → Execution → Validation → Optimization
agile: Sprint Planning → Iterative Execution → Adaptive Planning
enterprise: Stakeholder Analysis → Resource Allocation → Risk Management

test

Execute tests and generate reports.

When to use

Run tests
Check coverage
Set up test infrastructure

Usage

/sc test [target] [--type unit|integration|e2e|all] [--coverage] [--watch]

Execution

Detect test framework
Execute appropriate tests
Collect coverage data
Generate report with recommendations

troubleshoot

Diagnose and resolve issues.

When to use

Debugging errors
Build failures
Performance issues
Deployment problems

Usage

/sc troubleshoot [issue] [--type bug|build|performance|deployment] [--trace] [--fix]

Execution

Analyze issue description
Identify potential root causes
Execute systematic debugging
Propose and validate solutions
Apply fixes and verify

workflow

Generate structured implementation workflows from PRDs.

When to use

Planning feature implementation
Creating development roadmaps
Breaking down complex features
Sprint planning

Usage

/sc workflow [prd|description] [--strategy systematic|agile|mvp] [--output roadmap|tasks|detailed]

Strategies

systematic: Full analysis, architecture, dependencies, testing
agile: Epics, sprints, MVP, iterative delivery
mvp: Core features, rapid prototyping, validation

Output Formats

roadmap: Phase-based timeline with milestones
tasks: Epic/Story/Task hierarchy
detailed: Step-by-step with estimates and criteria

Global Options

Option	Effect
`--think`	Enable extended analysis (4K tokens)
`--think-hard`	Deep analysis mode (10K tokens)
`--c7`	Enable Context7 for framework patterns
`--seq`	Enable Sequential thinking
`--safe`	Conservative approach with extra validation
`--verbose`	Detailed output

Claude Code Integration

Glob/Grep/Read: File discovery and analysis
Edit/Write: Code generation and modification
Bash: Build and test execution
Task tool: Complex multi-step orchestration
TodoWrite: Progress tracking

Examples

/sc analyze src/ --focus security --depth deep
/sc build --type prod --clean --optimize
/sc cleanup --type imports --dry-run
/sc implement user-auth --type feature --with-tests
/sc workflow docs/prd.md --strategy agile --output tasks
/sc troubleshoot "build failing" --type build --trace

sc

SuperClaude Unified Workflow

Usage

Commands