💡 Welcome to SuperClaude Framework!

This manual covers all 25 commands, 15 specialized agents + business expert panel, 7 behavior modes, and 8 MCP servers with detailed usage and rich practical examples. Each feature is carefully designed to make your development work more efficient and intelligent.

🎯 Quick Start

Install SuperClaude

# Recommended method (pipx)
pipx install SuperClaude && pipx upgrade SuperClaude && SuperClaude install

# Or using npm
npm install -g @bifrost_inc/superclaude && superclaude install

# Or using pip
pip install SuperClaude && pip upgrade SuperClaude && SuperClaude install

First Time Usage

After installation, type in Claude Code:

/sc:help

This will display a list of all available commands. Let's start exploring!

💻 Development Workflow

Common development workflow commands to help you with full-cycle development from requirements to deployment:

/sc:brainstorm - Interactive Requirements Exploration
Transform vague ideas into clear technical specifications through Socratic dialogue

Syntax

/sc:brainstorm [--strategy systematic|agile|enterprise] [--depth shallow|normal|deep] [--parallel] [topic/idea]

Parameters

  • --strategy: : Exploration strategy
    • systematic
    • agile
    • enterprise
  • --depth: : Exploration depth
    • shallow
    • normal
    • deep
  • --parallel: : Enable parallel exploration paths
Example 1: Systematic Product Exploration
/sc:brainstorm --strategy systematic --depth deep "AI-driven project management tool"
✨ Effect:
  • Multi-expert analysis (architect, analyst, project manager)
  • Uses Sequential MCP for structured exploration framework
  • Generates complete requirements documentation

💡 Practical Scenarios

SaaS Product Concept Exploration
/sc:brainstorm --strategy systematic --depth shallow --parallel "Team collaboration project management tool with AI assistant"
Context:
Product concept scenario:

  • Have a vague idea for a team collaboration project management tool with AI assistant integration
  • Uncertain about core value proposition and target user groups
  • Unclear about specific AI integration scenarios
  • Need systematic exploration to clarify product positioning and feature scope
Result:
Requirements exploration completed with user stories, core features, and tech stack identified. Ready for design phase.
Team Collaboration Tool Development
/sc:brainstorm --strategy agile --depth normal "Team collaboration project management tool with AI assistant"
Context:
Development planning scenario:

  • Want to develop a team collaboration tool
  • Uncertain about core features that would provide real value
  • Need to identify differentiation advantages in competitive market
Result:
Core features and value proposition clarified through systematic dialogue. Ready for PRD creation.
Feature Prioritization Assessment
/sc:brainstorm --strategy enterprise --depth deep "Feature prioritization: User feedback system vs Advanced analytics vs Third-party integrations"
Context:
Prioritization challenge:

  • Product backlog has accumulated 20+ feature requests from various stakeholders
  • Limited development resources (small team)
  • Need data-driven prioritization to maximize impact
  • Must balance quick wins with long-term strategic features
Result:
Feature prioritization completed with data-driven recommendations and implementation roadmap.
💡 Best Practices:
  • The vaguer the idea, the better suited for this command
  • Let Claude guide the conversation and answer raised questions
  • Save generated requirements documents for subsequent development
/sc:implement - Feature Implementation
Use intelligent expert coordination and MCP integration to implement features and code

Syntax

/sc:implement [--type component|api|service|feature] [--framework react|vue|express] [--safe] [--with-tests] ""

Parameters

  • --type: Implementation type
    • component
    • api
    • service
    • feature
  • --framework: Tech framework (e.g., react, vue, angular, express, fastify)
  • --safe: Enable security review, activate security engineer
  • --with-tests: Auto-generate test code
Example 1.1: Quick Component
/sc:implement --type component --framework react "user login form"
✨ Effect:
  • Generates React component
  • Includes Hooks and state management
  • Automatic form validation
Example 1.2: API Endpoint
/sc:implement --type api --framework express --safe "payment processing interface"
✨ Effect:
  • Express REST API
  • Includes error handling and input validation
  • Security mode prevents common vulnerabilities
Example 1.3: Complete Feature Module
/sc:implement --type feature --framework react --with-tests --magic --c7 "real-time chat system"
✨ Effect:
  • Complete frontend and backend implementation
  • Includes unit tests and integration tests
  • Magic generates beautiful UI
  • Context7 provides best practices
  • Automatically sets up WebSocket connection
Example 1.4: Microservice Implementation
/sc:implement --type service --framework express --with-tests --seq --think-hard "order processing microservice"
✨ Effect:
  • Independent microservice architecture
  • Includes message queue integration
  • Sequential deep analysis of business logic
  • Auto-generates Docker configuration

💡 Practical Scenarios

File Upload Feature
/sc:implement --type feature --framework react --safe --with-tests "Large file upload with chunking and resume"
Context:
Implementation requirements:

  • Need to implement large file upload support with chunking mechanism
  • Must support files up to 2GB in size
  • Require progress tracking with real-time updates
  • Need resume capability to handle network interruptions
  • Must show accurate upload progress to users
Result:
File upload feature implemented with validation and progress tracking.
User Authentication System
/sc:implement --type api --framework express --safe --with-tests "User authentication system (registration, login, JWT)"
Context:
System requirements:

  • Need to implement complete user authentication system
  • Must include user registration with email validation
  • Require secure login with JWT token management
  • Tech stack: Express.js + JWT + bcrypt for password hashing
  • Must design user model with encrypted passwords
  • Need registration and login API endpoints with proper validation
  • Require authentication middleware for protected routes
Result:
Authentication system implemented with secure token handling and session management.
💡 Best Practices:
  • Description needs to be clear and explicit, including key requirements
  • Production code should always use --safe
  • Use --with-tests to ensure test coverage
/sc:design - System Design
Design system architecture, API interfaces, and component structure with scalable technical solutions

Syntax

/sc:design --type architecture --format diagram ""

Parameters

  • --type: Design type
    • architecture
    • api
    • component
    • database
  • --format: Output format
    • diagram
    • spec
    • code
Example 9.1: API Design
/sc:design --type api --format spec "User Authentication API"
✨ Effect:
  • OpenAPI specification
  • Endpoint definitions
  • Security schemes
Example 9.2: Database Design
/sc:design --type database --format code "E-commerce Order System"
✨ Effect:
  • Database schema
  • ER diagram
  • SQL scripts
Example 9.3: Microservices Architecture Design
/sc:design --type architecture --format diagram --ultrathink --c7 ""
✨ Effect:
  • Complete architecture diagram
  • Service communication design
  • Data flow diagram
  • Technology stack selection
  • Scalability planning

💡 Practical Scenarios

Real-time Collaboration API Design
/sc:design --type api --format spec "Real-time Document Collaboration API"
Context:
Design requirements:

  • Need to design a real-time collaborative document editing feature
  • Require proper API structure for multi-user editing
  • Must handle data synchronization and conflict resolution
  • Need real-time updates across all connected clients
Result:
API design completed with specifications and documentation ready for implementation.
Payment System Architecture Refactoring
/sc:design --type architecture --format diagram "Payment System Refactoring"
Context:
Refactoring challenges:

  • E-commerce system payment code is messy with high coupling between components
  • Difficult to add new payment providers or modify existing flows
  • Need to redesign architecture before refactoring
  • Must ensure clean separation of concerns and testability
Result:
System architecture defined with component interactions and deployment strategy documented.
💡 Best Practices:
  • Design before coding to avoid rework
  • Consider system scalability and maintainability
  • Use --format diagram to generate visual documentation
  • Conduct design reviews before implementation phase

💾 Session Management

Save and load your development sessions for cross-session context persistence:

/sc:save - Session Save
Use Serena MCP to save session context and discoveries

Syntax

/sc:save [--type session|learnings|context|all] [--checkpoint] [--summarize]

Parameters

  • --type: : Save type
    • session
    • learnings
    • context
    • all
  • --checkpoint: : Create recoverable checkpoint
  • --summarize: : Generate summary
Example 12.1: Quick Save
/sc:save --type session
✨ Effect:
  • Save current session
  • Fast execution
  • Auto timestamp
Example 12.2: Comprehensive Checkpoint
/sc:save --type all --checkpoint --summarize
✨ Effect:
  • Complete state save
  • Generate summary
  • Recoverable checkpoint

💡 Practical Scenarios

Save Debugging Session Progress
/sc:save "payment-bug-analysis"
Context:
Session scenario:

  • Working on complex payment integration bug
  • End of work day approaching
  • Made significant debugging progress that needs to be preserved
  • Want to continue investigation tomorrow without losing context
Result:
Debugging session saved with progress and findings documented for future continuation.
Document Project Architecture Learnings
/sc:save "project-architecture-overview"
Context:
Knowledge capture scenario:

  • Completed in-depth architectural discussion with team
  • Made important technology stack decisions
  • Need to preserve architectural rationale for future reference
  • Want to make knowledge accessible for team onboarding
Result:
Project learnings saved to persistent storage for knowledge retention.
Save Performance Optimization Insights
/sc:save "react-performance-optimization"
Context:
Optimization completion:

  • Just finished optimizing React component rendering performance
  • Discovered key insights about unnecessary re-renders
  • Applied React.memo and useCallback optimizations
  • Achieved significant performance improvements
  • Want to document solution for similar scenarios
Result:
System architecture defined with component interactions documented.
💡 Best Practices:
  • Save immediately after important breakthroughs
  • Create checkpoints every 30 minutes for long sessions
  • Use --summarize before ending sessions
/sc:load - Session Load
Use Serena MCP to load project context and historical sessions

Syntax

/sc:load [--type project|checkpoint|session] [--analyze] [--refresh] ""

Parameters

  • --type: : Load type
    • project
    • checkpoint
    • session
  • --analyze: : Auto-analyze project structure
  • --refresh: : Refresh context
Example 12.3: Load Project
/sc:load --type project --analyze ""
✨ Effect:
  • Load project context
  • Auto-analyze structure
  • Understand code architecture
Example 12.4: Restore Checkpoint
/sc:load --type checkpoint --refresh "session_20250118_1430"
✨ Effect:
  • Restore session state
  • Refresh context
  • Continue previous work

💡 Practical Scenarios

Continue Yesterday's Debugging Session
/sc:load "payment-bug-analysis"
Context:
Work resumption scenario:

  • Starting new work day
  • Was debugging authentication issue yesterday
  • Need to quickly restore context and continue from where left off
  • Want seamless workflow continuation without re-analyzing the problem
Result:
Session context restored successfully with full project state available.
Load Project Memory
/sc:load "ecommerce-platform"
Context:
Project activation scenario:

  • Switching to different project after working on another codebase
  • Need to recall project-specific context, architecture, and conventions
  • Want quick reactivation without manually reviewing documentation
Result:
Project context activated with architecture and development patterns loaded.
Restore Learning Context
/sc:load "nextjs-learning"
Context:
Learning resumption:

  • Was learning Next.js App Router architecture last week
  • Made notes and practiced with examples
  • Need to continue learning from where stopped
  • Want to recall key concepts and next learning steps
Result:
System architecture defined with component interactions documented.
💡 Best Practices:
  • Load project context immediately when starting new session
  • Save current session before switching projects, then load new project
  • Regularly use --refresh to refresh stale context
  • Use --analyze to automatically analyze project structure

🎯 Advanced Features

Powerful advanced commands for solving complex development scenarios:

/sc:reflect - Task Reflection
Task reflection and validation using Serena MCP analysis capabilities for quality assessment

Syntax

/sc:reflect [--analyze outcomes|process|quality] [--improve] [--task TasksID]

Parameters

  • --task: : Specify task ID to reflect on
  • --analyze: : Analysis dimension
    • outcomes
    • process
    • quality
  • --improve: : Auto-apply improvement suggestions
Example: Implementation Task Reflection
/sc:reflect --task --analyze quality --improve "implement user authentication"
✨ Effect:
  • Analyze implementation quality (code coverage, security)
  • Identify potential issues (insufficient error handling, performance concerns)
  • Generate improvement suggestions
  • Automatically apply safely improvable parts
  • Flag issues requiring manual review

💡 Practical Scenarios

Task Completion Validation
/sc:reflect --analyze outcomes --improve
Context:
Completed user authentication feature development, need to verify if all requirements are met.
Result:
Task completion validated with requirements coverage confirmed.
Code Quality Reflection
/sc:reflect --analyze process
Context:
Refactoring complete, need to evaluate if code quality meets standards.
Result:
Code quality validation completed with improvement areas identified.
Project Milestone Review
/sc:reflect --analyze quality --improve
Context:
Sprint ended, need to review achievements and issues of this iteration.
Result:
Sprint review completed with achievements documented and improvement opportunities identified.
💡 Best Practices:
  • Reflect promptly after completing important tasks
  • Use reflection results to optimize future work
  • Regular reflection improves development quality
  • Fix issues discovered through reflection promptly
/sc:select-tool - Tool Selection
Intelligent MCP tool selection based on complexity scoring and operation analysis

Syntax

/sc:select-tool "operation description" [--suggest] [--compare] [--explain]

Parameters

  • --suggest: : Recommend best tool combination
  • --compare: : Compare multiple tool solutions
  • --explain: : Explain selection reasoning
Example: Tool Selection Suggestion
/sc:select-tool --suggest --explain "Need to rename function names in 100 files"
✨ Effect:
  • Analyze operation complexity: Medium (batch editing)
  • Recommended tool: Morphllm MCP (batch pattern editing)
  • Alternative: Serena MCP (symbol renaming)
  • Explanation: Morphllm better suited for pattern-based batch replacements
  • Estimated efficiency gain: 80%

💡 Practical Scenarios

Complex Task Tool Selection
/sc:select-tool --suggest --explain "Implement user behavior data analysis and visualization reports"
Context:
Need to implement a complex data analysis feature, unsure which MCP tools are most appropriate.
Result:
Optimal tool combination recommended based on task complexity analysis.
Performance Optimization Tool Selection
/sc:select-tool --suggest --explain "API performance optimization"
Context:
API response is slow, need to select appropriate tools for performance analysis and optimization.
Result:
Tool workflow designed with appropriate MCP servers for systematic optimization.
Learning New Framework Tool Selection
/sc:select-tool --suggest --explain "Learn Next.js 14 new features"
Context:
Team needs to learn Next.js 14, need to select the best learning path and tools.
Result:
Build completed successfully with optimized production artifacts generated.
💡 Best Practices:
  • Consult this command when unsure which tool to use
  • Use --compare to understand pros/cons of different solutions
  • Choose appropriate tools based on project scale
  • Learn tool selection logic to improve efficiency
/sc:spawn - Task Orchestration
Meta-system task orchestration with intelligent breakdown and delegation of large complex tasks

Syntax

/sc:spawn "task description" [--strategy sequential|parallel|adaptive] [--breakdown auto] [--delegate agents]

Parameters

  • --strategy: : Execution strategy
    • sequential
    • parallel
    • adaptive
  • --breakdown: : Automatic task breakdown
  • --delegate: : Delegate to specialized agents
Example: Large Project Orchestration
/sc:spawn --strategy adaptive --breakdown auto --delegate agents "Build complete e-commerce admin system"
✨ Effect:
  • Task breakdown: User management, Product management, Order system, Payment integration, Data analytics
  • Agent assignment: backend-architect (architecture), security-engineer (payment security), frontend-architect (admin interface)
  • Execution strategy: Architecture design → Parallel development → Integration testing
  • Intelligent scheduling and progress tracking

💡 Practical Scenarios

Parallel Development of Multiple Features
/sc:spawn --strategy adaptive --breakdown auto "user avatar upload, comment system, search optimization"
Context:
Sprint needs to simultaneously develop 3 independent features, hoping to accelerate development through parallel processing.
Result:
Task orchestration completed with all parallel development streams executed successfully.
Multi-Environment Deployment
/sc:spawn --strategy parallel --breakdown auto "Deploy to test, staging, and production environments"
Context:
Need to simultaneously deploy to test, staging, and production environments.
Result:
Parallel deployment completed successfully across all target environments.
Complex Problem Divide and Conquer
/sc:spawn --strategy adaptive --breakdown auto "Analyze slow API, frontend lag, and database query performance"
Context:
System performance issues are complex, need to decompose into multiple sub-problems and analyze in parallel.
Result:
System architecture defined with component interactions documented.
💡 Best Practices:
  • Suitable for large, multi-module projects
  • Let system intelligently assign agents and strategies
  • Regularly check subtask progress
  • Use sequential strategy for complex dependencies
/sc:workflow - Workflow Generation
Generate structured implementation workflows from PRDs and feature requirements

Syntax

/sc:workflow [--strategy agile|systematic|enterprise] [--depth shallow|normal|deep] [--parallel] [--delegate manual|auto] ""

Parameters

  • --strategy: Workflow strategy
    • systematic
    • agile
    • enterprise
  • --depth: Workflow depth
    • shallow
    • normal
    • deep
  • --parallel: Enable parallel task execution
  • --delegate: Automatic task delegation
    • auto
Example 7.1: Agile Workflow
/sc:workflow --strategy agile "User Management System"
✨ Effect:
  • Agile methodology
  • User story breakdown
  • Iteration planning
Example 7.2: Systematic Workflow
/sc:workflow --strategy systematic --depth deep "@requirements.prd"
✨ Effect:
  • Systematic methodology
  • Detailed task breakdown
  • Dependency graph
Example 7.3: Enterprise Parallel Workflow
/sc:workflow --strategy enterprise --depth deep --parallel --delegate auto "@product-spec.md"
✨ Effect:
  • Enterprise-level process
  • Parallel task execution
  • Automatic task assignment
  • Gantt chart generation
  • Team collaboration plan

💡 Practical Scenarios

Feature Development Standard Process
/sc:workflow --strategy systematic --depth normal "New Feature Development Standard Process"
Context:
Team has many new members, need to standardize feature development process.
Result:
Development workflow structured with clear phases and team collaboration guidelines defined.
Bug Fix Process
/sc:workflow --strategy agile --depth shallow "Bug Fix Standard Process"
Context:
Bug fix process is irregular, often missing steps leading to rework.
Result:
Bug fix workflow standardized with investigation, resolution, and verification steps documented.
Enterprise Parallel Workflow
/sc:workflow --strategy enterprise --depth deep --parallel --delegate auto "@product-spec.md"
Context:
Large project needs multi-team collaboration, requires enterprise workflow planning.
Result:
Improvements applied with measurable performance gains achieved.
💡 Best Practices:
  • Ensure PRD contains clear requirement definitions
  • Use systematic strategy for resource planning
  • Regularly update workflow to track progress
  • Adjust approach based on team size
/sc:task - Complex Task Execution
Use intelligent workflow management and delegation to execute complex tasks

Syntax

/sc:task [--parallel] [--validate] [task description] [--delegate auto|files|folders]
Example: Large-Scale Refactoring
/sc:task --delegate auto --validate "refactor authentication system"
✨ Effect:
  • Auto task decomposition and delegation
  • Expert collaboration and execution
  • Risk assessment before execution

💡 Practical Scenarios

End-to-End Feature Implementation
/sc:task --parallel --validate "Integrate Stripe payment (requirements → design → implementation → testing → deployment)"
Context:
Need to complete a payment integration feature from requirements to deployment.
Result:
Feature implementation orchestrated through full workflow with all phases completed successfully.
Problem Diagnosis and Fix
/sc:task --parallel --validate "Production environment memory leak"
Context:
Production environment experiencing memory leak, need complete diagnosis and fix workflow.
Result:
Issue diagnosed and resolved through systematic troubleshooting workflow.
Project Initialization
/sc:task --parallel --validate "Next.js + TypeScript + Tailwind project"
Context:
Starting a new Next.js project, need complete project setup.
Result:
System architecture defined with component interactions documented.

Other Core Commands

More powerful feature commands

/sc:help - View All Commands
Quick access to all available SuperClaude commands and their functionality

Syntax

/sc:help
/sc:analyze - Code Quality Analysis
Comprehensive analysis of code quality, security, performance and architecture

Syntax

/sc:analyze [--focus quality|security|performance|architecture] [--depth quick|deep] [--format text|json|report] [--all-mcp] [--validate] ""

Parameters

  • --focus: Analysis focus
    • quality
    • security
    • performance
    • architecture
  • --depth: Analysis depth
    • quick
    • normal
    • deep
  • --format: Output format
    • text
    • json
    • report
  • --all-mcp: Enable all MCP servers for comprehensive analysis
  • --validate: Validate analysis results and generate improvement plan
Example 2.1: Quick Security Scan
/sc:analyze --focus security --depth quick "src/auth"
✨ Effect:
  • Quick security vulnerability identification
  • Completes scan in 5-10 seconds
  • Focus on authentication logic
Example 2.2: Performance Analysis
/sc:analyze --focus performance --depth normal "api/"
✨ Effect:
  • Standard performance analysis
  • Identifies performance bottlenecks
  • Provides optimization recommendations
Example 2.3: Deep Architecture Assessment
/sc:analyze --focus architecture --depth deep --format report --think-hard --seq "."
✨ Effect:
  • Comprehensive architecture analysis
  • Generates detailed report
  • Evaluates design pattern usage
  • Identifies architectural debt
  • Sequential provides refactoring suggestions
Example 2.4: Comprehensive Quality Review
/sc:analyze --focus quality --depth deep --format json --all-mcp --validate "src/"
✨ Effect:
  • Comprehensive code quality review
  • JSON format for CI/CD integration
  • Coverage and complexity analysis
  • Auto-generates improvement plan

💡 Practical Scenarios

New Feature Performance Analysis
/sc:analyze --focus performance --depth deep --format report "src/search"
Context:
Performance investigation:

  • Newly developed search feature has slow response times
  • Users experiencing delays of 2-3 seconds per search
  • Need to analyze performance bottlenecks
  • Must identify optimization opportunities quickly
Result:
Performance analysis completed with bottlenecks identified and optimization recommendations provided.
Legacy Code Quality Assessment
/sc:analyze --focus quality --depth deep --format json "src/legacy"
Context:
Technical debt evaluation:

  • Need to conduct comprehensive quality analysis of legacy codebase
  • Codebase inherited from previous team with unclear quality status
  • Must assess technical debt before planning refactoring efforts
  • Need to prioritize improvement work based on impact
Result:
Code quality assessment completed with actionable improvement recommendations.
💡 Best Practices:
  • Use --depth quick for initial analysis to quickly locate problem areas
  • Use --depth deep for in-depth analysis of critical modules
  • Regularly perform --focus security audits on core modules
  • Use --format report to generate shareable analysis reports for the team
  • Combine --all-mcp to use multiple MCP servers for comprehensive analysis
/sc:research - Deep Web Research
Use adaptive planning and intelligent search to perform deep web research

Syntax

/sc:research [--depth quick|standard|exhaustive] [--strategy planning|unified] ""

Parameters

  • --depth: Research depth
    • quick
    • standard
    • exhaustive
  • --strategy: Research strategy
    • planning_only
    • intent_planning
    • unified
  • --domains: Domain filtering (e.g., "github.com,stackoverflow.com")
Example 8.1: Quick Survey
/sc:research --depth quick "latest frontend framework comparison"
✨ Effect:
  • Quick overview
  • Key point summary
  • Completed in 5-10 minutes
Example 8.2: Standard Research
/sc:research --depth standard --strategy planning "microservices architecture best practices"
✨ Effect:
  • Standard depth research
  • Multi-source information aggregation
  • Practical recommendations
Example 8.3: Exhaustive Technical Research
/sc:research --depth exhaustive --strategy unified --serena "zero trust security architecture implementation guide"
✨ Effect:
  • Most exhaustive research
  • Comprehensive information collection
  • Comparison analysis tables
  • Serena saves research findings
  • Trend and prediction analysis

💡 Practical Scenarios

Technology Stack Research
/sc:research --strategy unified "React state management comparison 2024"
Context:
Technical decision:

  • Need to choose state management solution for new React project
  • Evaluating Redux vs Zustand vs Jotai vs React Context
  • Team has mixed experience levels
  • Want data-driven decision with pros/cons
Result:
Technology options analyzed with recommendations based on project requirements.
Security Best Practices Research
/sc:research --strategy unified "OAuth 2.0 security best practices and common vulnerabilities"
Context:
Security audit preparation:

  • Preparing for security audit of authentication system
  • Need to understand current best practices and standards
  • Want to identify gaps in current implementation
  • Must provide recommendations for improvements
Result:
Research completed with security best practices and implementation recommendations documented.
/sc:test - Test Execution
Execute tests and generate coverage analysis and quality reports

Syntax

/sc:test [--type unit|integration|e2e|all] [--coverage] [--watch] [--fix] [--parallel] [--concurrency N] [--validate] [--verbose] ""

Parameters

  • --type: Test type
    • unit
    • integration
    • e2e
    • all
  • --coverage: Generate test coverage report
  • --watch: Watch mode, automatically rerun tests when files change
  • --fix: Automatically fix test issues (timeouts, outdated assertions, etc.)
  • --parallel: Execute tests in parallel
  • --concurrency: Concurrency count (e.g., --concurrency 4)
  • --validate: Result validation and reporting
  • --verbose: Detailed log output
Example 3.1: Unit Tests
/sc:test --type unit --coverage "src/utils"
✨ Effect:
  • Run unit tests
  • Generate coverage report
  • Fast execution
Example 3.2: Watch Mode
/sc:test --type unit --watch "src/"
✨ Effect:
  • Auto-rerun tests on file changes
  • Instant feedback
  • Suitable for TDD development
Example 3.3: E2E Test Suite
/sc:test --type e2e --fix --play --verbose ""
✨ Effect:
  • End-to-end testing
  • Auto-fix failing test cases
  • Playwright browser automation
  • Detailed log output
Example 3.4: Complete Test Pipeline
/sc:test --type all --coverage --parallel --concurrency 4 --validate "."
✨ Effect:
  • All tests execute in parallel
  • 4x speed improvement
  • Complete coverage analysis
  • Result validation and reporting

💡 Practical Scenarios

Comprehensive Feature Testing
/sc:test --type all --coverage --validate "src/auth"
Context:
Feature validation:

  • Just completed user authentication feature implementation
  • Need to verify all functionality works as specified
  • Must test edge cases and error scenarios
  • Require comprehensive test coverage before merge
Result:
Tests identified failures requiring fixes before proceeding.
Regression Testing After Refactoring
/sc:test --type all --coverage --validate "src/payments"
Context:
Refactoring verification:

  • Just completed major refactoring of payment processing module
  • Changed internal implementation but API should remain unchanged
  • Need to ensure no existing functionality was broken
  • Must verify backward compatibility
Result:
All tests passed with comprehensive coverage report generated. Ready for code review.
💡 Best Practices:
  • Run tests before improvements to ensure test coverage
  • For large-scale improvements, proceed in stages using --scope to control range
  • Always use --safe mode for production code
  • Compare performance metrics after improvements to ensure positive gains
/sc:improve - Code Improvement
Improve code maintainability, performance, and security through systematic refactoring and quality enhancement

Syntax

/sc:improve [--type quality|performance|security|maintainability] [--safe] [--preview] [--interactive] [--iterations N] ""

Parameters

  • --type: Improvement type
    • quality
    • performance
    • maintainability
  • --safe: Safe mode, all changes require test validation
  • --preview: Preview mode, no actual modifications
  • --interactive: Interactively confirm each improvement
  • --iterations: Number of improvement iterations
Example 10.1: Performance Optimization
/sc:improve --type performance --safe "src/api/"
✨ Effect:
  • Performance optimization
  • Safe mode
  • Benchmark testing
Example 10.2: Code Quality
/sc:improve --type quality --preview "src/"
✨ Effect:
  • Quality improvement preview
  • No actual modifications
  • Improvement checklist
Example 10.3: Comprehensive Refactoring
/sc:improve --type maintainability --interactive --iterations 3 --morph ""
✨ Effect:
  • Progressive refactoring
  • 3 iteration rounds
  • Interactive confirmation
  • Morphllm batch refactoring
  • Maintainability score improvement

💡 Practical Scenarios

Code Quality Improvement
/sc:improve --type quality --safe "src/auth/legacy"
Context:
Code quality enhancement:

  • Legacy authentication module has accumulated technical debt
  • Code is functional but difficult to maintain and test
  • Need to improve without breaking existing functionality
  • Want to follow modern best practices
Result:
Code quality improvements completed with enhanced maintainability and test coverage.
Performance Optimization
/sc:improve --type performance --safe "src/api/products"
Context:
Performance improvement:

  • API response times averaging 800ms, target is <200ms
  • Database queries are inefficient
  • No caching layer implemented
  • React components re-rendering unnecessarily
Result:
Performance optimizations applied with measurable improvements achieved.
💡 Best Practices:
  • Run tests before improvements to ensure test coverage
  • For large-scale improvements, proceed in stages using --iterations for iterative improvement
  • Always use --safe mode for production code
  • Use --preview to preview improvement effects before applying
  • Compare performance metrics after improvements to ensure positive gains
/sc:build - Project Build
Compile, package, and prepare project for deployment with multi-environment configuration and optimization support

Syntax

/sc:build [--type dev|prod|all] [--clean] [--optimize] [--validate] [--parallel] [--verbose] [--environments ""] [--dockerize] ""

Parameters

  • --type: Build type
    • dev
    • prod
    • all
  • --clean: Clean old builds
  • --optimize: Enable build optimization
  • --validate: Build result validation
  • --parallel: Parallel build tasks
  • --verbose: Detailed output logs
  • --environments: Multiple environment builds (e.g., --environments "dev,staging,prod")
  • --dockerize: Generate Docker images
Example 5.1: Development Build
/sc:build --type dev --verbose "frontend/"
✨ Effect:
  • Development environment build
  • Detailed log output
  • Fast hot reload
Example 5.2: Production Build
/sc:build --type prod --clean "."
✨ Effect:
  • Production environment optimization
  • Clean old builds
  • Compression and minification
Example 5.3: Optimized Build Pipeline
/sc:build --type prod --clean --optimize --validate --parallel "."
✨ Effect:
  • Full optimization production build
  • Parallel build tasks
  • Build result validation
  • Performance analysis report
  • Tree-shaking and code splitting
Example 5.4: Multi-Environment Build
/sc:build --type all --environments "dev,staging,prod" --dockerize ""
✨ Effect:
  • Multiple environments build simultaneously
  • Generate Docker images
  • Environment-specific configuration
  • Ready for deployment

💡 Practical Scenarios

Production Build with Optimization
/sc:build --type prod --optimize --validate --clean
Context:
Production deployment preparation:

  • Preparing for v2.0 production release
  • Need optimized build with minification and tree-shaking
  • Must ensure all assets are properly bundled
  • Require validation of build artifacts
Result:
Build completed successfully with optimized production artifacts generated.
CI/CD Integration Build
/sc:build --type prod --optimize --validate --parallel --clean
Context:
Continuous integration setup:

  • Setting up automated build pipeline in GitHub Actions
  • Need consistent, reproducible builds across environments
  • Must optimize and validate build outputs
  • Require parallel processing for faster builds
Result:
Build completed successfully with optimized production artifacts generated.
💡 Best Practices:
  • Run tests before production builds to ensure code quality
  • Use --clean to avoid issues from residual old files
  • Use --watch in development for better efficiency
  • Check build size report to identify large dependencies
/sc:cleanup - Code Cleanup
Systematically clean codebase, remove dead code, and optimize project structure

Syntax

/sc:cleanup [--type imports|code|all] [--safe] [--preview] [--aggressive] [--interactive] [--backup]

Parameters

  • --type: : Cleanup type
    • imports
    • code
    • all
  • --safe: : Safe mode, conservative handling
  • --preview: : Preview mode, no actual modifications
  • --aggressive: : Aggressive mode (use with caution)
  • --interactive: : Confirm each cleanup item
  • --backup: : Auto backup
Example 11.1: Clean Imports
/sc:cleanup --type imports --safe "src/"
✨ Effect:
  • Clean unused imports
  • Conservative handling
  • Fast execution
Example 11.2: Remove Dead Code
/sc:cleanup --type code --preview "."
✨ Effect:
  • Identify dead code
  • Preview mode
  • Cleanup report
Example 11.3: Aggressive Cleanup
/sc:cleanup --type all --aggressive --interactive --backup ""
✨ Effect:
  • Comprehensive deep cleanup
  • Aggressive mode (use with caution)
  • Confirm each item
  • Auto backup
  • Cleanup statistics report

💡 Practical Scenarios

Legacy Code Cleanup
/sc:cleanup --type code --safe --preview "src/"
Context:
Code cleanup requirements:

  • Project has accumulated unused code and deprecated features
  • Dead code affecting codebase maintainability
  • Need to safely remove obsolete components
  • Must ensure no breaking changes to active features
Result:
Legacy code removed with verification tests confirming no functionality loss.
Comprehensive Codebase Cleanup
/sc:cleanup --type all --safe --backup
Context:
Codebase maintenance:

  • Project has accumulated technical debt over time
  • Unused imports and dead code affecting maintainability
  • Need comprehensive cleanup of entire codebase
  • Want to ensure safe removal with backup
Result:
Codebase cleanup completed with unused code removed and dependencies updated.
💡 Best Practices:
  • Clean regularly to avoid technical debt accumulation
  • Run tests before cleanup to ensure no functionality breaks
  • Always use --safe mode for backup
  • Verify application runs normally after cleanup
/sc:document - Documentation Generation
Generate clear and accurate technical documentation for code, APIs, and components

Syntax

/sc:document [--type inline|api|guide] [--style brief|detailed] [--format markdown] [--toc] ""

Parameters

  • --type: : Documentation type
    • inline
    • api
    • guide
  • --style: : Documentation style
    • brief
    • detailed
  • --format: : Output format
    • markdown
  • --toc: : Generate table of contents
Example 13.1: Inline Documentation
/sc:document --type inline --style brief "utils.js"
✨ Effect:
  • Add code comments
  • Brief style
  • Fast generation
Example 13.2: API Documentation
/sc:document --type api --style detailed "src/api/"
✨ Effect:
  • Complete API documentation
  • Parameter descriptions
  • Example code
Example 13.3: User Guide
/sc:document --type guide --style detailed --format markdown --toc ""
✨ Effect:
  • Complete user guide
  • Table of contents structure
  • Diagram illustrations
  • Best practices
  • Search friendly

💡 Practical Scenarios

API Documentation Generation
/sc:document --type api --format markdown "src/api/"
Context:
Documentation needs:

  • Backend API lacks comprehensive documentation
  • Frontend team struggling to understand endpoint contracts
  • Need to generate up-to-date API reference
  • Want to include request/response examples in markdown format
Result:
API documentation generated with comprehensive endpoint references and examples.
Component Library Documentation
/sc:document --type code --format markdown "src/components/"
Context:
Component documentation:

  • React component library growing without documentation
  • Developers unsure how to use existing components
  • Need to document props, usage examples, and best practices
  • Want comprehensive markdown documentation for component library
Result:
Component documentation created with usage examples and prop specifications.
💡 Best Practices:
  • Keep documentation in sync with code updates
  • Provide rich usage examples
  • API docs should include complete request/response examples
  • Keep documentation concise and accessible, avoid over-technicality
/sc:estimate - Development Estimation
Provide development time and resource estimates for tasks, features, or projects

Syntax

/sc:estimate [--type time|complexity|effort] [--unit hours|days] [--breakdown] [--team-size N] ""

Parameters

  • --type: : Estimation type
    • time
    • complexity
    • effort
  • --unit: : Time unit
    • hours
    • days
  • --breakdown: : Detailed task breakdown
  • --team-size: : Team size (affects parallelism)
Example 14.1: Time Estimation
/sc:estimate --type time --unit hours "Implement login functionality"
✨ Effect:
  • Work hours estimation
  • Accurate to hours
  • Includes buffer time
Example 14.2: Complexity Assessment
/sc:estimate --type complexity "Microservice decomposition"
✨ Effect:
  • Technical complexity
  • Risk assessment
  • Difficulty level
Example 14.3: Detailed Project Estimation
/sc:estimate --type effort --unit days --breakdown --team-size 5 ""
✨ Effect:
  • Complete effort breakdown
  • Consider team size
  • Task dependencies
  • Burndown chart prediction
  • Cost estimation

💡 Practical Scenarios

Feature Development Estimation
/sc:estimate --type time --unit days --breakdown --team-size 3 "Analytics dashboard with charts, filters, CSV export"
Context:
Sprint planning:

  • Product manager requesting estimate for new analytics dashboard
  • Feature includes data visualization, filtering, and export capabilities
  • Need to provide realistic timeline for sprint planning
  • Team has 3 developers available
Result:
Development effort estimated with timeline and resource requirements defined.
Technical Debt Refactoring Estimate
/sc:estimate --type time --unit days --breakdown "Refactor authentication system to modern architecture"
Context:
Refactoring planning:

  • Need to refactor legacy authentication system
  • Current code is difficult to maintain and test
  • Must maintain backward compatibility
  • Want realistic estimate before committing resources
Result:
Refactoring effort estimated with phased approach and timeline defined.
💡 Best Practices:
  • Provide detailed feature descriptions for better accuracy
  • Adjust estimates based on team experience
  • Reserve 20-30% buffer time
  • Use historical data to calibrate estimation model
/sc:explain - Code Explanation
Explain code, concepts, and system behavior in clear language

Syntax

/sc:explain [--level beginner|intermediate|expert] [--focus logic|architecture|performance|security] [target]

Parameters

  • --level: : Explanation depth
    • beginner
    • intermediate
    • expert
  • --focus: : Explanation focus
    • logic
    • architecture
    • performance
    • security
Example 1: Explain Complex Function
/sc:explain --level intermediate --focus security @utils/encryption.js
✨ Effect:
  • Step-by-step explanation of encryption algorithm
  • Explain why this solution was chosen
  • Point out security critical points
  • Explain parameters and return values
Example 2: Architecture Explanation
/sc:explain --level beginner --focus architecture "Microservices Architecture"
✨ Effect:
  • Explain microservices concept in simple language
  • Compare differences with monolithic architecture
  • Explain applicable scenarios
  • Provide introductory examples

💡 Practical Scenarios

Complex Algorithm Explanation
/sc:explain --level beginner "src/cache/lru-cache.ts"
Context:
Learning scenario:

  • New team member joining project
  • Struggling to understand custom caching algorithm
  • Code lacks comments and documentation
  • Need clear explanation of how it works
Result:
Algorithm explanation provided with step-by-step breakdown and visual examples.
Architecture Pattern Explanation
/sc:explain --level intermediate --focus architecture "Event sourcing pattern in payment service"
Context:
Code review discussion:

  • Team discussing microservices event-driven architecture
  • Some developers unfamiliar with event sourcing pattern
  • Need to explain the pattern and why it's used
  • Want to show benefits and trade-offs
Result:
Architecture pattern explained with implementation guidance and best practices.
💡 Best Practices:
  • Choose appropriate --level based on audience
  • Provide specific context when requesting explanations
  • Use --focus to concentrate on aspects of interest
  • Ask follow-up questions for deeper understanding
/sc:index - Project Documentation Index
Generate comprehensive project documentation and knowledge base index with intelligent organization

Syntax

/sc:index [--type codebase|docs|all] [--depth shallow|deep] [--output markdown|json|html]

Parameters

  • --type: : Index type
    • codebase
    • docs
    • all
  • --depth: : Index depth
    • shallow
    • deep
  • --output: : Output format
Example: Codebase Index
/sc:index --type codebase --depth deep --output markdown
✨ Effect:
  • Scan entire codebase
  • Generate directory structure tree
  • List all modules and dependencies
  • Extract major functions and classes
  • Generate PROJECT_INDEX.md

💡 Practical Scenarios

Project Knowledge Base Indexing
/sc:index --type codebase --depth shallow --output markdown
Context:
New employee needs to quickly understand project, establish comprehensive code index.
Result:
Project knowledge base indexed for fast semantic search and navigation.
Incremental Index Update
/sc:index --type docs --depth deep --output json
Context:
Project frequently updated, need to regularly update index to keep current.
Result:
Index updated with recent changes incorporated for improved search accuracy.
Specific Module Indexing
/sc:index --type all --depth shallow --output html
Context:
Refactoring payment, only need to index related code.
Result:
Module index generated with dependency graph and documentation ready for review.
💡 Best Practices:
  • Run index when joining new projects
  • Update index regularly to stay in sync
  • Use index for quick navigation in large projects
  • Index serves as onboarding docs for new members
/sc:spec-panel - Specification Review
Multi-expert specification review and improvement using renowned specification and software engineering experts

Syntax

/sc:spec-panel @spec-document [--mode review|critique|improve] [--focus clarity|completeness|feasibility]

Parameters

  • --mode: : Review mode
    • review
    • critique
    • improve
  • --focus: : Review focus
    • clarity
    • completeness
    • feasibility
Example: API Specification Review
/sc:spec-panel --mode improve --focus completeness @specs/api-design.md
✨ Effect:
  • Expert panel review (architects, technical writers)
  • Identify missing endpoints and parameters
  • Point out incomplete error handling
  • Provide improvement suggestions and examples
  • Generate improved specification version

💡 Practical Scenarios

API Specification Review
/sc:spec-panel --mode improve --focus completeness "docs/api-spec.yaml"
Context:
Specification review:

  • Drafted new REST API specification for microservices
  • Need expert review for best practices and potential issues
  • Want to ensure scalability and maintainability
  • Require feedback on naming conventions and structure
Result:
Expert panel review completed with actionable recommendations and implementation priorities set.
Database Schema Review
/sc:spec-panel --mode critique --focus feasibility "schemas/ecommerce.sql"
Context:
Schema validation:

  • Designed database schema for e-commerce platform
  • Includes users, products, orders, payments tables
  • Need expert validation for normalization and performance
  • Want to identify potential scaling issues
Result:
Database schema reviewed by experts with optimization suggestions and best practices documented.
💡 Best Practices:
  • Review immediately after completing spec draft
  • Use critique mode to discover hidden issues
  • Revise spec based on review suggestions
  • Repeat review until quality standards are met
/sc:troubleshoot - Troubleshooting
Systematically diagnose and resolve code issues, build failures, and runtime errors

Syntax

/sc:troubleshoot [--type bug|build|performance|config] [--trace] [--fix] [--safe-mode] ""

Parameters

  • --type: Problem type
    • bug
    • performance
    • build
  • --trace: Deep stack trace analysis
  • --fix: Attempt automatic fix
  • --safe-mode: Safe mode, use conservative fix strategy
Example 6.1: Performance Issue
/sc:troubleshoot --type performance --trace "API response slow"
✨ Effect:
  • Performance issue location
  • Generates flame graph
  • Identifies bottleneck
Example 6.2: Build Failure
/sc:troubleshoot --type build --fix
✨ Effect:
  • Auto-detect build issues
  • Attempt automatic fix
  • Provide solutions
Example 6.3: Production Environment Debugging
/sc:troubleshoot --type bug --trace --fix --safe-mode --seq ""
✨ Effect:
  • Safe mode debugging
  • Deep stack trace
  • Sequential root cause analysis
  • Conservative fix strategy
  • Performance impact assessment

💡 Practical Scenarios

Production API Failure Investigation
/sc:troubleshoot --type bug --trace --fix --safe-mode "checkout API 500 errors"
Context:
Critical production issue:

  • Users reporting 500 errors on checkout API
  • Error rate suddenly spiked to 15% from normal 0.1%
  • Need to quickly identify root cause
  • Must restore service as soon as possible
Result:
Root cause identified and fix implemented with monitoring to prevent recurrence.
Performance Degradation Root Cause Analysis
/sc:troubleshoot --type performance --trace --fix "dashboard performance"
Context:
Performance issue investigation:

  • Dashboard loading time increased from 2s to 8s over past week
  • No recent code changes to frontend
  • Users complaining about slow experience
  • Need to find what changed and fix it
Result:
Performance issue diagnosed and resolved with optimization recommendations applied.
💡 Best Practices:
  • Provide complete error information and context
  • Use --trace for deep stack trace analysis
  • Use --safe-mode for production issues to ensure safety
  • Verify problem is resolved after applying fix
  • Document diagnosis process to prevent recurrence
/sc:git - Git Operations
Use intelligent commit messages and workflow optimization to perform Git operations

Syntax

/sc:git [commit|merge|rebase|pr|flow] [--smart-commit] [--interactive] [--push] [--create-pr] [--squash] [--create] [--title "title"] [--auto-description] [parameters]

Parameters

  • commit: Commit changes
  • merge: Merge branches
  • rebase: Rebase operation
  • pr: Pull Request operation
  • flow: Complete Git workflow
  • --smart-commit: Smart commit message generation
  • --interactive: Interactive operation
  • --push: Push to remote
  • --create-pr: Create Pull Request
  • --squash: Squash commits
  • --create: Create (PR)
  • --title: PR title
  • --auto-description: Auto-generate description
Example 4.1: Smart Commit
/sc:git commit --smart-commit
✨ Effect:
  • Auto-generate specification commit messages
  • Analyze code change content
  • Follow Conventional Commits
Example 4.2: Interactive Merge
/sc:git merge --interactive ""
✨ Effect:
  • Smart conflict resolution
  • Step-by-step merge guidance
  • Provide best practice suggestions
Example 4.3: Complete Git Workflow
/sc:git flow --smart-commit --push --create-pr ""
✨ Effect:
  • Auto-create branch
  • Smart commit messages
  • Push and create PR
  • Generate change summary

💡 Practical Scenarios

Feature Development Git Workflow
/sc:git flow --smart-commit --push --create-pr
Context:
Feature branch management:

  • Working on new dashboard analytics feature
  • Made multiple commits during development
  • Need to create clean commit history before PR
  • Want to push to remote and create pull request
Result:
Changes committed and submitted for code review following project conventions.
Hotfix Deployment
/sc:git flow --smart-commit --push --create-pr --title "Hotfix: Payment callback race condition"
Context:
Critical bug fix:

  • Production payment processing bug discovered
  • Need to create emergency hotfix from production branch
  • Must deploy fix quickly while maintaining git best practices
  • Require automated testing before merge
Result:
Hotfix deployed to production with verification and rollback plan documented.
💡 Best Practices:
  • Use --smart-commit to ensure commit message quality
  • Use --interactive for complex merge operations
  • Always test before git flow to ensure code quality
  • Use meaningful branch names and PR titles
/sc:business-panel - Business Expert Panel
Multi-expert business analysis with adaptive interaction patterns

Syntax

/sc:business-panel [--mode discussion|debate|socratic] [--experts "expert1,expert2"] [--focus domain] [document]

Parameters

  • --mode: : Analysis mode
    • discussion
    • debate
    • socratic
  • --experts: : Specify expert list (comma-separated)
  • --focus: : Focus domain (innovation, strategy, marketing, risk, systems, communication, organization)
Example: Business Strategy Analysis
/sc:business-panel --mode discussion --focus strategy "SaaS pricing model evaluation"
✨ Effect:
  • Expert panel review (business strategists, economists)
  • Analyze market positioning and competitive landscape
  • Evaluate pricing models and revenue implications
  • Provide strategic recommendations
  • Generate actionable insights

💡 Practical Scenarios

Product Strategy Review
/sc:business-panel --mode sequential "SaaS project management tool - freemium vs paid subscription strategy"
Context:
Strategic planning:

  • Launching new SaaS product for project management
  • Need to validate market positioning and pricing strategy
  • Evaluating freemium vs subscription model
  • Want expert guidance on go-to-market approach
Result:
Business strategy expert panel completed with market positioning and go-to-market recommendations.
Business Model Pivot Evaluation
/sc:business-panel --mode debate "Pivot from B2C to B2B enterprise model"
Context:
Pivot decision:

  • Current B2C model not achieving growth targets
  • Considering pivot to B2B enterprise sales
  • Need to evaluate feasibility and risks
  • Want structured debate on pros/cons
Result:
Business model analysis completed with pivot decision framework and risk assessment.

🤖 Specialized Agents

What are Specialized Agents?

SuperClaude Framework includes 15 specialized agents, each with deep expertise in specific domains. Agents can be automatically activated or manually specified through flag parameters.

🎨 Frontend Development Agent

frontend-architect
Create accessible, high-performance user interfaces with focus on user experience and modern frameworks

Expertise:

  • Modern frameworks like React, Vue, Angular
  • Responsive design and mobile optimization
  • Web accessibility (WCAG 2.1)
  • Performance optimization and code splitting

⚙️ Backend Development Agent

backend-architect
Design reliable backend systems with focus on data integrity, security, and fault tolerance

Expertise:

  • RESTful and GraphQL API design
  • Database architecture and optimization
  • Authentication and authorization
  • Microservices architecture

🏗️ System Architecture Agent

system-architect
Design scalable system architecture with focus on maintainability and long-term technical decisions

Expertise:

  • System design patterns
  • Scalability architecture
  • Technology selection
  • Architecture documentation

🐍 Python Expert Agent

python-expert
Deliver production-ready, secure, high-performance Python code following SOLID principles

Expertise:

  • Python best practices
  • FastAPI, Django, Flask
  • Data processing and analysis
  • Asynchronous programming

🚀 DevOps Agent

devops-architect
Automate infrastructure and deployment processes with focus on reliability and observability

Expertise:

  • CI/CD pipelines
  • Docker and Kubernetes
  • Monitoring and logging
  • Infrastructure as Code

🔧 Refactoring Expert Agent

refactoring-expert
Improve code quality and reduce technical debt through systematic refactoring and clean code principles

Expertise:

  • Code smell identification
  • Refactoring patterns
  • Code quality metrics
  • Technical debt management

🎓 Other Specialized Agents

SuperClaude also includes the following specialized agents:

  • security-engineer - Security vulnerability identification and compliance
  • quality-engineer - Comprehensive testing strategies
  • performance-engineer - Performance optimization
  • learning-guide - Programming education
  • root-cause-analyst - Root cause analysis
  • requirements-analyst - Requirements discovery
  • technical-writer - Technical documentation
  • socratic-mentor - Socratic teaching method
  • business-panel-experts - Business strategy panel (9 experts)

🚩 Flag Parameters Reference

Flag parameters allow you to customize command behavior. Here are all available flags:

⚡ Mode Activation Flags

These flags activate specific working modes to enhance AI capabilities and interaction methods

FlagDescriptionCostCommands
--brainstormActivate collaborative discovery thinking mode through Socratic dialogue to explore requirements+2-3KAll commands
--introspectShow thinking process transparency, let AI display reasoning steps+1-2KAll commands
--task-manageEnable multi-step task management, automatically track and organize complex tasks+1KAll commands
--orchestrateEnable multi-tool parallel execution, coordinate multiple MCP servers and tools+3-5KAll commands
--token-efficientEnable token optimization mode, reduce token consumption while maintaining quality-30-50%All commands
--planEnable planning mode, generate detailed plan before executionStandardimplement, design, refactor
--validateEnable validation mode, automatically validate outputs and resultsStandardimplement, test, build
--parallelEnable parallel execution, process multiple tasks simultaneouslyStandardtest, analyze, research
--interactiveEnable interactive mode, step-by-step confirmation and adjustmentStandardbrainstorm, design

🔍 Analysis Depth Flags

Control AI's analysis depth, balancing speed and detail

FlagCostDescriptionScenario
--think~4KStandard analysis depth, suitable for regular development tasksDaily development
--think-hard~10KDeep analysis with multi-angle thinking and validationComplex problems
--ultrathink~32KMaximum depth analysis, exhausting all possibilitiesCritical decisions
--depth shallowLowQuick overview, suitable for time-sensitive situationsQuick checks
--depth normalStandardBalance speed and detail (default)Regular analysis
--depth deepHighComprehensive in-depth analysis for complex scenariosDetailed assessment

🔌 MCP Server Control

Selectively activate MCP servers for specialized capabilities

FlagAliasServerPurpose
--c7--context7Context7Framework documentation query, get official latest docs and best practices
--seq--sequentialSequentialComplex reasoning analysis, multi-step systematic thinking
--magic--magicMagicUI component generation based on 21st.dev modern component library
--morph--morphllmMorphllmBatch code editing, pattern-based rapid modifications
--serena--serenaSerenaProject memory management, semantic code understanding and session persistence
--play--playwrightPlaywrightBrowser automation testing, E2E testing and UI validation

⚙️ Execution Control Flags

Control command execution methods and behavior

FlagDescriptionExample
--dry-runSimulate execution without making actual changes/sc:implement --dry-run
--forceForce execution, skip confirmation prompts/sc:cleanup --force
--auto-commitAutomatically commit changes to Git/sc:implement --auto-commit
--no-testSkip testing steps/sc:build --no-test

💡 Combination Usage Examples

Flags can be combined for more powerful functionality:

  • /sc:analyze --think-hard --serena --c7 "src/api"
    Use deep thinking, project memory, and official docs for API code analysis
  • /sc:implement --brainstorm --plan --validate "user authentication"
    Collaboratively explore requirements, plan implementation, and validate results
  • /sc:improve --token-efficient --morph --dry-run "src/"
    Preview code improvements using token optimization and batch editing tools

💡 Practical Tips

Here are some real development scenarios and recommended command combinations:

📦 Develop New Feature from Scratch
/sc:brainstorm "user authentication feature" --depth deep
/sc:design --think
/sc:implement --plan --validate
/sc:test --parallel
/sc:document
/sc:git "feat: add user authentication"

Workflow Explanation:

  1. Requirements exploration: Clarify feature scope and technical approach
  2. System design: Design authentication flow and data models
  3. Feature implementation: Write code and validate
  4. Test validation: Run test suites in parallel
  5. Generate documentation: Auto-generate API documentation
  6. Commit code: Create standard Git commit
🐛 Emergency Bug Fix Process
/sc:troubleshoot --depth deep
/sc:analyze --focus security
/sc:implement --validate
/sc:test --parallel
/sc:git "fix: resolve authentication bypass"
🔧 Code Refactoring and Performance Optimization
/sc:analyze --depth deep
/sc:improve --plan
/sc:test --validate
/sc:cleanup
🎨 React Component Development
/sc:design "user profile card component"
/sc:implement --persona frontend-architect
/sc:test --focus accessibility
/sc:document

🎓 Learning Resources

Official Documentation

Community Resources

💡 Tip:

Having issues? Check the FAQ or submit an Issue on GitHub.