SuperClaude Unified Workflow
Comprehensive workflow system with 17 subcommands for structured development tasks.
Usage
/sc [command] [target] [options]Commands
| 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 hierarchyexecute- Execute with orchestrationstatus- View task statusanalytics- Performance dashboarddelegate- 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