Command Reference

Version: 4.1.9•Total Commands: 29•Updated: December 2025

This document is the complete command reference manual for SuperClaude Framework, containing detailed descriptions, parameters, usage examples, and best practices for all slash commands.

Quick Reference

Category	Commands
Development	/sc:implement /sc:build /sc:improve /sc:cleanup /sc:git
Documentation	/sc:document /sc:explain /sc:index
Planning & Requirements	/sc:brainstorm /sc:design /sc:estimate /sc:workflow
Project Management	/sc:pm /sc:task /sc:spawn /sc:select-tool /sc:index-repo
Research & Analysis	/sc:research /sc:business-panel /sc:spec-panel
Session Management	/sc:load /sc:save /sc:agent
Testing & Quality	/sc:test /sc:analyze /sc:troubleshoot /sc:reflect
Utilities	/sc:help /sc:recommend

Development

5 Commands

/sc:implement

Advanced

Feature and code implementation with intelligent persona activation and MCP integration

Syntax

/sc:implement [options] "[feature-description]"

Options

Flag	Values	Description
--type	component, api, service, feature	Specifies the artifact type: 'component', 'api', 'service', or 'feature'.
--framework	react, vue, express, etc.	Specifies the target framework (e.g., react, vue) to tailor code generation patterns.
--safe	-	Activates conservative mode: avoids destructive changes and focuses on non-breaking updates.
--with-tests	-	Automatically generates unit and integration tests for the implemented code.

Examples

React component implementation

/sc:implement --type component --framework react "user profile component"

API service implementation (safe mode + tests)

/sc:implement --type api --safe --with-tests "user authentication API"

Full-stack feature

/sc:implement --type feature --with-tests "payment processing system"

Vue framework component

/sc:implement --type component --framework vue "dashboard widget"

Express backend service

/sc:implement --type service --framework express --safe "file upload service"

React secure component (with tests)

/sc:implement --type component --framework react --safe --with-tests "admin panel"

Next.js page implementation

/sc:implement --type feature --framework nextjs "user settings page"

Pure API implementation (no tests)

/sc:implement --type api "notification endpoint"

/sc:build

Advanced

Build, compile, and package projects with intelligent error handling and optimization

Syntax

/sc:build [options] [target]

Options

Flag	Values	Description
--type	dev, prod, test	Target environment for the build: 'dev', 'prod', or 'test'.
--clean	-	Removes previous build artifacts before starting.
--optimize	-	Activates performance optimizations like minification and tree-shaking.
--verbose	-	Enables detailed logging of internal agent decisions and state changes.

Examples

Development build

/sc:build --type dev

Production build

/sc:build --type prod --clean --optimize

Verbose build

/sc:build --verbose

/sc:improve

Advanced

Apply systematic improvements to code quality, performance, and maintainability

Syntax

/sc:improve [options] [target]

Options

Flag	Values	Description
--type	quality, performance, maintainability, style	Focus area for improvements: 'quality', 'performance', 'maintainability', or 'style'.
--safe	-	Safe mode (conservative improvements)
--interactive	-	Prompts for user approval before applying each improvement suggestion.
--preview	-	Generates a comprehensive diff of proposed changes without applying them.
--validate	-	Runs verification steps (e.g., linters, tests) after changes are applied.

Examples

Quality improvement

/sc:improve --type quality src/auth

Performance optimization (safe mode)

/sc:improve --type performance --safe api/

Interactive style improvement

/sc:improve --type style --interactive components/

Maintainability improvement (preview)

/sc:improve --type maintainability --preview src/utils

Quality improvement (validate + interactive)

/sc:improve --type quality --validate --interactive src/services

Safe performance optimization (preview)

/sc:improve --type performance --safe --preview database/

Comprehensive quality review

/sc:improve --type quality --validate --safe src/

Style unification (safe + preview)

/sc:improve --type style --safe --preview --validate components/

/sc:cleanup

Advanced

Systematically clean up code, remove dead code, and optimize project structure

Syntax

/sc:cleanup [options] [target]

Options

Flag	Values	Description
--type	code, imports, files, all	Target for cleanup: 'code' (formatting), 'imports' (unused), 'files' (temp), or 'all'.
--safe	-	Safe mode (conservative cleanup)
--aggressive	-	Applies stricter cleanup rules that may alter code structure significantly.
--interactive	-	Interactive cleanup
--preview	-	Generates a comprehensive diff of proposed changes without applying them.

Examples

Safe code cleanup

/sc:cleanup --type code --safe src/

Import cleanup

/sc:cleanup --type imports

Comprehensive interactive cleanup

/sc:cleanup --type all --interactive

Aggressive file cleanup (preview)

/sc:cleanup --type files --aggressive --preview

Safe code cleanup (preview)

/sc:cleanup --type code --safe --preview src/legacy

Interactive import cleanup

/sc:cleanup --type imports --interactive

Comprehensive aggressive cleanup

/sc:cleanup --type all --aggressive

Safe comprehensive cleanup (preview + interactive)

/sc:cleanup --type all --safe --preview --interactive

/sc:git

Basic

Git operations with intelligent commit messages and workflow optimization

Syntax

/sc:git [options] "[operation]"

Options

Flag	Values	Description
--smart-commit	-	Uses AI to analyze staged changes and generate semantic commit messages.
--interactive	-	Guides through git workflows with step-by-step prompts.

Examples

Smart commit

/sc:git --smart-commit

Create feature branch

/sc:git "feature/user-auth"

Interactive operations

/sc:git --interactive

Documentation

3 Commands

/sc:document

Basic

Generate focused documentation for components, functions, APIs, and features

Syntax

/sc:document [options] [target]

Options

Flag	Values	Description
--type	inline, external, api, guide	Target format: 'inline' (comments), 'external' (markdown), 'api' (specs), or 'guide'.
--style	brief, detailed	Level of detail: 'brief' (summary) or 'detailed' (full specs).

Examples

Inline documentation

/sc:document --type inline src/utils.ts

API documentation

/sc:document --type api --style detailed api/

User guide

/sc:document --type guide --style brief

/sc:explain

Basic

Provide clear explanations of code, concepts, and system behavior

Syntax

/sc:explain [options] "[target]"

Options

Flag	Values	Description
--level	basic, intermediate, advanced	Target audience expertise: 'basic', 'intermediate', or 'advanced'.
--format	text, examples, interactive	Format of explanation: 'text', 'examples', or 'interactive'.
--context	[domain]	Limits explanation context to a specific domain (e.g., 'auth', 'database').

Examples

Basic explanation

/sc:explain --level basic src/auth/middleware.ts

Advanced detailed explanation

/sc:explain --level advanced --format examples "JWT authentication flow"

Interactive explanation

/sc:explain --format interactive "database optimization"

/sc:index

Basic

Generate comprehensive project documentation and knowledge base

Syntax

/sc:index [options] [target]

Options

Flag	Values	Description
--type	docs, api, structure, readme	Type of index to generate: 'docs', 'api', 'structure', or 'readme'.
--format	md, json, yaml	Format of the result: 'text', 'json', or 'report'.

Examples

Documentation index

/sc:index --type docs

API index

/sc:index --type api --format json api/

Project structure index

/sc:index --type structure --format yaml

Planning & Requirements

4 Commands

/sc:brainstorm

Advanced

Interactive requirements discovery through Socratic dialogue and systematic exploration

Syntax

/sc:brainstorm [options] "[topic/idea]"

Options

Flag	Values	Description
--strategy	systematic, agile, enterprise	Selects the strategic approach: 'systematic' for thoroughness, 'agile' for speed, or 'enterprise' for scale.
--depth	shallow, normal, deep	Controls the depth of analysis: 'shallow' for quick scans, 'deep' for comprehensive reviews.
--parallel	-	Enable parallel exploration paths

Examples

Systematic product discovery (deep analysis)

/sc:brainstorm --strategy systematic --depth deep "AI-powered project management tool"

Agile feature exploration (parallel paths)

/sc:brainstorm --strategy agile --parallel "real-time collaboration features"

Enterprise solution validation

/sc:brainstorm --strategy enterprise "enterprise data analytics platform"

Quick shallow exploration

/sc:brainstorm --depth shallow "mobile app idea"

Systematic parallel deep exploration

/sc:brainstorm --strategy systematic --depth deep --parallel "microservices architecture"

Agile iterative exploration

/sc:brainstorm --strategy agile --depth normal "user authentication improvements"

/sc:design

Basic

Design system architecture, APIs, and component interfaces with comprehensive specifications

Syntax

/sc:design [options] [target]

Options

Flag	Values	Description
--type	architecture, api, component, database	Design type
--format	diagram, spec, code	Format of the result: 'text', 'json', or 'report'.

Examples

System architecture design

/sc:design --type architecture --format diagram user-management-system

API specification design

/sc:design --type api --format spec payment-api

Component interface design

/sc:design --type component --format code notification-service

Database schema design

/sc:design --type database --format diagram e-commerce-db

/sc:estimate

Basic

Provide intelligent development estimates for tasks, features, or projects

Syntax

/sc:estimate [options] "[target]"

Options

Flag	Values	Description
--type	time, effort, complexity	Estimation type
--unit	hours, days, weeks	Time unit
--breakdown	-	Enable detailed breakdown

Examples

Time estimation

/sc:estimate --type time --unit days "authentication system"

Complexity analysis

/sc:estimate --type complexity --breakdown "API refactoring"

/sc:workflow

Advanced

Generate structured implementation workflows from PRDs and feature requirements

Syntax

/sc:workflow [options] "[feature-description]"

Options

Flag	Values	Description
--strategy	systematic, agile, enterprise	Workflow strategy
--depth	shallow, normal, deep	Workflow depth
--parallel	-	Enable parallel execution

Examples

Systematic workflow

/sc:workflow --strategy systematic "payment integration"

Agile iterative workflow

/sc:workflow --strategy agile --depth deep "user onboarding"

Project Management

5 Commands

/sc:pm

Meta

Project Manager Agent - Default orchestration agent that coordinates all sub-agents and manages workflows seamlessly

Syntax

/sc:pm [options] "[request]"

Options

Flag	Values	Description
--strategy	brainstorm, direct, wave	Defines the execution mode: 'brainstorm' for exploratory ideation and requirement discovery through interactive questioning (ideal for vague or unclear requests), 'direct' for immediate implementation without extensive planning (best for clear, well-defined tasks with known scope), or 'wave' for phased rollout with structured implementation stages (optimal for complex multi-phase projects requiring systematic progression). Choose brainstorm when requirements need clarification, direct for straightforward tasks, or wave for large-scale changes.
--verbose	-	Enables detailed logging of internal agent decisions, sub-agent activations, workflow state changes, and delegation patterns. Useful for understanding PM Agent's reasoning process, debugging workflow issues, learning orchestration strategies, or tracking which specialist agents are activated for specific tasks. Provides transparency into strategy selection, task breakdown logic, and execution flow.

Examples

Default usage (no command needed, describe requirements directly, PM Agent handles orchestration automatically)

/sc:pm "Need to add payment processing to the app"

Explicit strategy selection (using wave strategy)

/sc:pm --strategy wave "Improve application security"

Brainstorm mode (PM Agent auto-detects need for exploration)

/sc:pm "Maybe we could improve the user experience?"

Explicit brainstorm strategy (force requirement discovery)

/sc:pm --strategy brainstorm "Add new features to dashboard"

Direct strategy (immediate implementation for clear requirements)

/sc:pm --strategy direct "Fix the login button alignment on mobile"

Verbose mode (track agent orchestration decisions)

/sc:pm --verbose "Refactor the API layer"

Wave strategy with verbose logging (complex project with visibility)

/sc:pm --strategy wave --verbose "Migrate from REST to GraphQL"

Multi-stage project workflow (authentication system)

/sc:pm --strategy wave "Implement complete user authentication with OAuth, 2FA, and session management"

Debugging workflow (performance investigation)

/sc:pm --verbose "Investigate and fix dashboard loading performance issues"

Performance optimization project (systematic improvement)

/sc:pm --strategy wave "Optimize application performance across frontend, backend, and database"

/sc:task

Advanced

Complex task execution with intelligent workflow management and delegation

Syntax

/sc:task [options] "[task-description]"

Options

Flag	Values	Description
--strategy	systematic, agile, enterprise	Defines task execution approach: 'systematic' for methodical step-by-step progression with comprehensive planning and validation at each stage (best for complex, unfamiliar tasks requiring careful analysis), 'agile' for iterative rapid development with frequent validation cycles (ideal for evolving requirements or experimental features), or 'enterprise' for large-scale operations with governance, documentation, and cross-team coordination (suited for mission-critical changes affecting multiple systems). Choose systematic for thoroughness, agile for speed and flexibility, or enterprise for organizational scale.
--parallel	-	Enables parallel execution of independent operations when task can be decomposed into non-dependent subtasks. Automatically identifies opportunities for concurrent processing to reduce total execution time. Particularly effective for multi-file edits, batch operations, or tasks with clear component boundaries. Use when optimizing for speed and operations have no sequential dependencies.
--delegate	-	Enables intelligent delegation to specialized sub-agents based on task domain and complexity. Task agent analyzes requirements and routes subtasks to appropriate specialists (e.g., frontend-architect for UI, security-engineer for auth, performance-engineer for optimization). Use for complex tasks spanning multiple domains or requiring specialized expertise. Enhances quality through expert-level execution.

Examples

Systematic task execution

/sc:task --strategy systematic "implement authentication"

Parallel task execution with delegation

/sc:task --parallel --delegate "refactor API endpoints"

Agile strategy (iterative development)

/sc:task --strategy agile "build interactive data visualization dashboard"

Enterprise strategy (large-scale migration)

/sc:task --strategy enterprise "migrate 50+ microservices to Kubernetes"

Parallel execution (independent operations)

/sc:task --parallel "update all component prop types to TypeScript"

Delegation to specialists (complex domain task)

/sc:task --delegate "implement end-to-end encryption for messaging feature"

Systematic with parallelization (thorough + fast)

/sc:task --strategy systematic --parallel "refactor legacy codebase to modern patterns"

Agile with full delegation and parallelization (rapid multi-domain development)

/sc:task --strategy agile --delegate --parallel "add real-time collaboration features across frontend and backend"

/sc:spawn

Meta

Meta-system task orchestration with intelligent breakdown and delegation

Syntax

/sc:spawn [complex-task] [options]

Options

Flag	Values	Description
--strategy	sequential, parallel, adaptive	Defines task coordination approach: 'sequential' for step-by-step execution where each phase must complete before the next begins (ideal for dependent tasks with strict ordering requirements), 'parallel' for concurrent execution of independent subtasks to maximize speed (best for tasks with clear boundaries and no dependencies), or 'adaptive' for intelligent dynamic routing that analyzes complexity and adjusts strategy automatically (recommended for complex multi-domain projects with mixed dependency patterns). Choose sequential for ordered workflows, parallel for maximum throughput, or adaptive for uncertain complexity.
--depth	normal, deep	Controls task decomposition granularity: 'normal' provides standard breakdown into major phases and components (suitable for most projects with clear structure), 'deep' performs recursive decomposition into fine-grained subtasks with comprehensive dependency analysis (essential for complex legacy systems, architectural migrations, or when thorough planning is critical). Use normal for typical projects, deep for maximum planning detail and risk mitigation.

Examples

Complex feature implementation

/sc:spawn "implement user authentication system"

Large-scale system operation

/sc:spawn --strategy adaptive --depth deep "migrate legacy monolith to microservices"

Cross-domain infrastructure

/sc:spawn "establish CI/CD pipeline with security scanning"

Sequential strategy (ordered workflow)

/sc:spawn --strategy sequential "redesign database schema and migrate production data"

Parallel strategy (independent components)

/sc:spawn --strategy parallel "implement API documentation, client SDKs, and usage analytics simultaneously"

Normal depth (standard planning)

/sc:spawn --depth normal "add multi-language support to application"

Deep depth (comprehensive analysis)

/sc:spawn --depth deep "refactor monolithic application into domain-driven microservices"

Parallel with normal depth (fast standard project)

/sc:spawn --strategy parallel --depth normal "build mobile app for iOS and Android platforms"

Sequential with deep depth (complex ordered migration)

/sc:spawn --strategy sequential --depth deep "modernize legacy COBOL system to cloud-native architecture"

Task Hierarchy Visualization

spawn orchestration creates multi-level breakdown:

Level 1: High-level phases (PM Agent coordination)
  ├─ Level 2: Major components (Task Agent execution)
  │   ├─ Level 3: Specific implementations (Specialist Agents)
  │   └─ Level 4: Granular subtasks (depth=deep only)

Example: "Build e-commerce platform"
  ├─ Phase 1: Architecture & Design
  │   ├─ Database schema design (backend-architect)
  │   ├─ API contracts definition (backend-architect)
  │   └─ UI/UX wireframes (frontend-architect)
  ├─ Phase 2: Core Implementation
  │   ├─ Product catalog (backend + frontend)
  │   ├─ Shopping cart (backend + frontend)
  │   └─ Payment integration (security-engineer + backend)
  └─ Phase 3: Testing & Deployment
      ├─ E2E testing (quality-engineer)
      └─ Production deployment (devops-architect)

/sc:select-tool

Basic

Intelligent MCP tool selection based on complexity scoring and operation analysis

Syntax

/sc:select-tool [options]

Options

Flag	Values	Description
--analyze	-	Performs deep analysis of current project context, task complexity, and available MCP tools to recommend optimal tool selection. Evaluates factors including: codebase size, operation type, performance requirements, and tool capabilities. Outputs complexity score (0-1), recommended tools, and confidence level. Useful for understanding which tools are best suited for your specific scenario before execution.
--explain	-	Provides detailed reasoning and decision logic behind tool selection recommendations. Explains why specific tools were chosen over alternatives, including trade-off analysis, capability matching, and efficiency considerations. Educational mode that helps users learn tool selection patterns and understand the intelligent routing system. Combine with --analyze for comprehensive tool selection education.

Examples

Analyze tool selection

/sc:select-tool --analyze

Explain tool selection reasoning

/sc:select-tool --explain

Combined analysis and explanation (learning mode)

/sc:select-tool --analyze --explain

Performance optimization workflow with tool selection

# Step 1: Analyze optimal tools for performance task
/sc:select-tool --analyze --explain

# Step 2: Use recommended tools for execution
# (Based on analysis: Sequential for profiling, Serena for code navigation)

/sc:index-repo

Basic

Repository indexing for context optimization (94% token reduction: 58K → 3K)

Syntax

/sc:index-repo [path]

Examples

Index current repository

/sc:index-repo .

Index specific directory

/sc:index-repo src/

Large repository with performance metrics

/sc:index-repo .

Incremental re-indexing workflow

# Initial index
/sc:index-repo .

# After significant code changes (e.g., feature branch merge, refactoring)
/sc:index-repo .  # Re-index to update project understanding

# Target specific changed area for faster update
/sc:index-repo src/features/authentication/

Multi-module project indexing strategy

# Monorepo with multiple packages
/sc:index-repo packages/backend/    # Index backend module
/sc:index-repo packages/frontend/   # Index frontend module
/sc:index-repo packages/shared/     # Index shared utilities

# Or index entire monorepo at once
/sc:index-repo .                    # Comprehensive index

Research & Analysis

3 Commands

/sc:research

Advanced

Deep web research with adaptive planning and intelligent search

Syntax

/sc:research [options] "[query]"

Options

Flag	Values	Description
--depth	quick, standard, deep, exhaustive	Depth of search: 'quick' (summary), 'standard', 'deep' (comprehensive), or 'exhaustive'.
--strategy	planning, intent, unified	Research approach: 'planning', 'intent', or 'unified'.

Examples

Basic research (default depth)

/sc:research "latest developments in quantum computing 2024"

Deep competitive analysis

/sc:research --depth deep "competitive analysis of AI coding assistants"

Unified strategy research

/sc:research --strategy unified "best practices for distributed systems"

Quick fact query

/sc:research --depth quick "current React version"

Academic-level deep research

/sc:research --depth exhaustive "machine learning optimization techniques"

Intent planning research

/sc:research --strategy intent "cloud architecture patterns"

Deep + planning combination

/sc:research --depth deep --strategy planning "microservices security best practices"

Standard research (explicit)

/sc:research --depth standard "database scaling strategies"

/sc:business-panel

Advanced

Multi-expert business strategy analysis with 9 renowned business thinkers

Syntax

/sc:business-panel [options] "[topic]"

Options

Flag	Values	Description
--mode	discussion, debate, socratic	Analysis mode
--experts	[name1,name2,...]	Expert selection

Examples

Market entry strategy analysis

/sc:business-panel --mode discussion "market entry strategy"

Debate mode

/sc:business-panel --mode debate --experts porter,godin "pricing strategy"

Socratic exploration

/sc:business-panel --mode socratic "digital transformation"

/sc:spec-panel

Advanced

Multi-expert specification review and improvement with renowned software engineering experts

Syntax

/sc:spec-panel [options] "[specification]"

Options

Flag	Values	Description
--mode	discussion, critique, socratic	Review mode
--experts	[name1,name2,...]	Expert selection
--focus	requirements, architecture, testing, compliance	Review focus
--iterations	[N]	Number of iterations
--format	standard, structured, detailed	Format of the result: 'text', 'json', or 'report'.

Examples

Requirements specification review

/sc:spec-panel --focus requirements "API specification"

Architecture critique mode

/sc:spec-panel --mode critique --focus architecture "microservices design"

Detailed iterative review

/sc:spec-panel --iterations 3 --format detailed "security policy"

Socratic testing review

/sc:spec-panel --mode socratic --focus testing "test coverage strategy"

Compliance discussion review

/sc:spec-panel --mode discussion --focus compliance "GDPR requirements"

Expert-specific architecture review

/sc:spec-panel --experts fowler,beck --focus architecture "domain-driven design"

Multi-round structured requirements review

/sc:spec-panel --iterations 5 --format structured --focus requirements "user stories"

Critique mode testing review (detailed)

/sc:spec-panel --mode critique --focus testing --format detailed "integration tests"

Comprehensive specification review

/sc:spec-panel --mode discussion --focus requirements --iterations 3 --format detailed "system specification"

Session Management

3 Commands

/sc:load

Basic

Session lifecycle management with Serena MCP integration for project context loading

Syntax

/sc:load [target] [options]

Options

Flag	Values	Description
--type	project, config, deps, checkpoint	Load type
--refresh	-	Refresh cache
--analyze	-	Enable analysis

Examples

Load project context

/sc:load --type project src/

Load checkpoint

/sc:load --type checkpoint "auth-feature"

Refresh and analyze

/sc:load --refresh --analyze

/sc:save

Basic

Session lifecycle management with Serena MCP integration for session context persistence

Syntax

/sc:save [name] [options]

Options

Flag	Values	Description
--type	session, learnings, context, all	Save type
--summarize	-	Generate summary
--checkpoint	-	Create checkpoint

Examples

Save session

/sc:save --type session "auth-complete"

Save learnings

/sc:save --type learnings --summarize

Create checkpoint

/sc:save --checkpoint "midpoint"

/sc:agent

Advanced

SC Agent - Session controller that orchestrates the complete workflow of investigation, implementation, and review

Syntax

Examples

Agent starts automatically at session start, takes over complete workflow after user describes task

/sc:agent # No manual invocation required, auto-activated

Testing & Quality

4 Commands

/sc:test

Advanced

Execute tests with coverage analysis and automated quality reporting

Syntax

/sc:test [options] [target]

Options

Flag	Values	Description
--type	unit, integration, e2e, all	Scope of testing: 'unit', 'integration', 'e2e', or 'all'.
--coverage	-	Generates a code coverage report identifying untested lines.
--watch	-	Re-runs tests automatically when file changes are detected.
--fix	-	Attempts to automatically resolve minor test failures like formatting or snapshot mismatches.

Examples

Basic test execution

/sc:test

Unit test coverage analysis

/sc:test --type unit --coverage src/components

End-to-end browser testing

/sc:test --type e2e

Development watch mode (auto-fix)

/sc:test --watch --fix

Integration testing

/sc:test --type integration

Comprehensive testing (with coverage)

/sc:test --type all --coverage

Unit test watch mode

/sc:test --type unit --watch

E2E testing (auto-fix)

/sc:test --type e2e --fix

Coverage watch mode

/sc:test --coverage --watch

/sc:analyze

Basic

Comprehensive code analysis across quality, security, performance, and architecture domains

Syntax

/sc:analyze [options] [target]

Options

Flag	Values	Description
--focus	quality, security, performance, architecture	Domain to analyze: 'quality', 'security', 'performance', or 'architecture'.
--depth	quick, deep	Controls the depth of analysis: 'shallow' for quick scans, 'deep' for comprehensive reviews.
--format	text, json, report	Format of the result: 'text', 'json', or 'report'.

Examples

Comprehensive project analysis

/sc:analyze

Focused security assessment (deep)

/sc:analyze --focus security --depth deep src/auth

Performance optimization analysis (report format)

/sc:analyze --focus performance --format report

Quick quality check

/sc:analyze --focus quality --depth quick src/components

Architecture deep analysis (JSON output)

/sc:analyze --focus architecture --depth deep --format json

Security quick scan

/sc:analyze --focus security --depth quick

Performance deep analysis

/sc:analyze --focus performance --depth deep api/

Quality report (deep)

/sc:analyze --focus quality --depth deep --format report src/

/sc:troubleshoot

Basic

Diagnose and resolve issues in code, builds, deployments, and system behavior

Syntax

/sc:troubleshoot [options] "[issue-description]"

Options

Flag	Values	Description
--type	bug, build, performance, deployment	Category of the issue: 'bug', 'build', 'performance', or 'deployment'.
--trace	-	Outputs detailed execution traces to pinpoint failure origins.
--fix	-	Attempts to automatically apply patches for identified issues.

Examples

Bug diagnosis

/sc:troubleshoot --type bug "login form not submitting"

Build issues

/sc:troubleshoot --type build --trace "build failing on CI"

Performance issues

/sc:troubleshoot --type performance --fix "API response slow"

/sc:reflect

Basic

Task reflection and validation using Serena MCP analysis capabilities

Syntax

/sc:reflect [options] [target]

Options

Flag	Values	Description
--type	task, session, completion	Scope of reflection: 'task' (current item), 'session' (history), or 'completion' (goal check).
--analyze	-	Performs exhaustive reasoning to uncover hidden patterns or risks.
--validate	-	Runs verification steps (e.g., linters, tests) after changes are applied.

Examples

Task reflection

/sc:reflect --type task --analyze

Session review

/sc:reflect --type session

Completion validation

/sc:reflect --type completion --validate

Utilities

2 Commands

/sc:help

Basic

List all available /sc commands and their functionality

Syntax

/sc:help [command-name]

Examples

Show all command help

/sc:help

Specific command help

/sc:help implement

System Guides

MCP Server Integration

Available Servers

Server	Purpose	API Key	Auto-Activation Triggers
context7	Official library documentation	No	Import statements, framework keywords
sequential	Multi-step reasoning	No	`--think`, debugging, complex analysis
magic	UI component generation	Yes	`component`, `UI`, frontend requests
playwright	Browser automation	No	`test`, `e2e`, `browser`
morphllm	Code transformations	Yes	Multi-file edits, refactoring
serena	Semantic code understanding	No	Large projects, session management
tavily	Web search	Yes (free tier)	`/sc:research`, `latest`
chrome-devtools	Performance analysis	No	`performance`, `debug`

Server Combinations

yaml

Free (No API Keys):
  - context7 + sequential + playwright + serena

Learning:
  - context7 + sequential

Web Development:
  - magic + context7 + playwright

Deep Research:
  - tavily + sequential + serena

Enterprise Refactoring:
  - serena + morphllm + sequential

Configuration

MCP servers are configured in ~/.claude.json:

json

{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp@latest"]
    },
    "tavily": {
      "command": "npx",
      "args": ["-y", "tavily-mcp@latest"],
      "env": {"TAVILY_API_KEY": "${TAVILY_API_KEY}"}
    }
  }
}

Best Practices

1. Command Selection Guide

Scenario	Recommended Command	Reason
New project kickoff	`/sc:brainstorm`	Structured requirements discovery
Feature implementation	`/sc:implement`	Intelligent persona coordination
Code review	`/sc:analyze`	Multi-dimensional analysis
Test execution	`/sc:test`	Coverage and quality reporting
Deep research	`/sc:research`	Adaptive multi-source search
Daily tasks	`/sc:pm`	Auto-orchestration (default)

2. Flag Combination Patterns

bash

# Deep security analysis
/sc:analyze --focus security --depth deep

# Comprehensive testing
/sc:test --type all --coverage

# Safe implementation
/sc:implement "feature" --safe --with-tests

# Detailed research
/sc:research "topic" --depth exhaustive --strategy unified

3. Workflow Patterns

New Feature Development:

bash

/sc:brainstorm "feature idea" --strategy systematic
/sc:design "feature" --type architecture
/sc:workflow "implementation plan"
/sc:implement "feature" --with-tests
/sc:test --coverage
/sc:document --type api

Bug Fixing:

bash

/sc:troubleshoot "bug description" --trace
/sc:analyze --focus quality --depth deep
/sc:implement "fix" --safe
/sc:test --type regression

Code Optimization:

bash

/sc:analyze --focus performance
/sc:improve --type performance --safe
/sc:cleanup --type all --interactive
/sc:test --coverage

4. Token Efficiency

Task Complexity	Token Budget	Recommended Approach
Simple (typo)	200	Direct fix
Medium (bug fix)	1,000	Confidence check
Complex (new feature)	2,500	Full workflow

Confidence Check ROI: Spending 100-200 tokens can save 5,000-50,000 tokens

Quick Reference Card

Core Commands

bash

# Discovery & Planning
/sc:brainstorm "idea"        # Structured brainstorming
/sc:design "system"          # Architecture design
/sc:workflow "task"          # Workflow planning

# Development
/sc:implement "feature"      # Code implementation
/sc:improve path/            # Code improvement
/sc:test --coverage          # Test execution

# Research
/sc:research "topic"         # Web research
/sc:analyze path/            # Code analysis

# Session Management
/sc:save "checkpoint"        # Save session
/sc:load "session"           # Load session
/sc                          # List all commands

Common Flags

bash

--think         # Enable sequential reasoning
--think-hard    # Enable deep analysis
--c7            # Force Context7 activation
--no-mcp        # Disable MCP servers
--all-mcp       # Enable all MCP servers
--coverage      # Include test coverage
--depth quick   # Research depth control
--safe          # Safe mode
--with-tests    # Include tests
--interactive   # Interactive mode

Installation & Upgrade

Installation

To install the SuperClaude Framework CLI:

bash

npm install -g @superclaude/cli

Or run via npx:

bash

npx @superclaude/cli init

Upgrade

To upgrade to the latest version:

bash

npm update -g @superclaude/cli

Check version:

bash

/sc:version

Command Reference

Version: 4.1.9•Total Commands: 29•Updated: December 2025

This document is the complete command reference manual for SuperClaude Framework, containing detailed descriptions, parameters, usage examples, and best practices for all slash commands.

Quick Reference

Category	Commands
Development	/sc:implement /sc:build /sc:improve /sc:cleanup /sc:git
Documentation	/sc:document /sc:explain /sc:index
Planning & Requirements	/sc:brainstorm /sc:design /sc:estimate /sc:workflow
Project Management	/sc:pm /sc:task /sc:spawn /sc:select-tool /sc:index-repo
Research & Analysis	/sc:research /sc:business-panel /sc:spec-panel
Session Management	/sc:load /sc:save /sc:agent
Testing & Quality	/sc:test /sc:analyze /sc:troubleshoot /sc:reflect
Utilities	/sc:help /sc:recommend

Development

5 Commands

/sc:implement

Advanced

Feature and code implementation with intelligent persona activation and MCP integration

Syntax

/sc:implement [options] "[feature-description]"

Options

Flag	Values	Description
--type	component, api, service, feature	Specifies the artifact type: 'component', 'api', 'service', or 'feature'.
--framework	react, vue, express, etc.	Specifies the target framework (e.g., react, vue) to tailor code generation patterns.
--safe	-	Activates conservative mode: avoids destructive changes and focuses on non-breaking updates.
--with-tests	-	Automatically generates unit and integration tests for the implemented code.

Examples

React component implementation

/sc:implement --type component --framework react "user profile component"

API service implementation (safe mode + tests)

/sc:implement --type api --safe --with-tests "user authentication API"

Full-stack feature

/sc:implement --type feature --with-tests "payment processing system"

Vue framework component

/sc:implement --type component --framework vue "dashboard widget"

Express backend service

/sc:implement --type service --framework express --safe "file upload service"

React secure component (with tests)

/sc:implement --type component --framework react --safe --with-tests "admin panel"

Next.js page implementation

/sc:implement --type feature --framework nextjs "user settings page"

Pure API implementation (no tests)

/sc:implement --type api "notification endpoint"

/sc:build

Advanced

Build, compile, and package projects with intelligent error handling and optimization

Syntax

/sc:build [options] [target]

Options

Flag	Values	Description
--type	dev, prod, test	Target environment for the build: 'dev', 'prod', or 'test'.
--clean	-	Removes previous build artifacts before starting.
--optimize	-	Activates performance optimizations like minification and tree-shaking.
--verbose	-	Enables detailed logging of internal agent decisions and state changes.

Examples

Development build

/sc:build --type dev

Production build

/sc:build --type prod --clean --optimize

Verbose build

/sc:build --verbose

/sc:improve

Advanced

Apply systematic improvements to code quality, performance, and maintainability

Syntax

/sc:improve [options] [target]

Options

Flag	Values	Description
--type	quality, performance, maintainability, style	Focus area for improvements: 'quality', 'performance', 'maintainability', or 'style'.
--safe	-	Safe mode (conservative improvements)
--interactive	-	Prompts for user approval before applying each improvement suggestion.
--preview	-	Generates a comprehensive diff of proposed changes without applying them.
--validate	-	Runs verification steps (e.g., linters, tests) after changes are applied.

Examples

Quality improvement

/sc:improve --type quality src/auth

Performance optimization (safe mode)

/sc:improve --type performance --safe api/

Interactive style improvement

/sc:improve --type style --interactive components/

Maintainability improvement (preview)

/sc:improve --type maintainability --preview src/utils

Quality improvement (validate + interactive)

/sc:improve --type quality --validate --interactive src/services

Safe performance optimization (preview)

/sc:improve --type performance --safe --preview database/

Comprehensive quality review

/sc:improve --type quality --validate --safe src/

Style unification (safe + preview)

/sc:improve --type style --safe --preview --validate components/

/sc:cleanup

Advanced

Systematically clean up code, remove dead code, and optimize project structure

Syntax

/sc:cleanup [options] [target]

Options

Flag	Values	Description
--type	code, imports, files, all	Target for cleanup: 'code' (formatting), 'imports' (unused), 'files' (temp), or 'all'.
--safe	-	Safe mode (conservative cleanup)
--aggressive	-	Applies stricter cleanup rules that may alter code structure significantly.
--interactive	-	Interactive cleanup
--preview	-	Generates a comprehensive diff of proposed changes without applying them.

Examples

Safe code cleanup

/sc:cleanup --type code --safe src/

Import cleanup

/sc:cleanup --type imports

Comprehensive interactive cleanup

/sc:cleanup --type all --interactive

Aggressive file cleanup (preview)

/sc:cleanup --type files --aggressive --preview

Safe code cleanup (preview)

/sc:cleanup --type code --safe --preview src/legacy

Interactive import cleanup

/sc:cleanup --type imports --interactive

Comprehensive aggressive cleanup

/sc:cleanup --type all --aggressive

Safe comprehensive cleanup (preview + interactive)

/sc:cleanup --type all --safe --preview --interactive

/sc:git

Basic

Git operations with intelligent commit messages and workflow optimization

Syntax

/sc:git [options] "[operation]"

Options

Flag	Values	Description
--smart-commit	-	Uses AI to analyze staged changes and generate semantic commit messages.
--interactive	-	Guides through git workflows with step-by-step prompts.

Examples

Smart commit

/sc:git --smart-commit

Create feature branch

/sc:git "feature/user-auth"

Interactive operations

/sc:git --interactive

Documentation

3 Commands

/sc:document

Basic

Generate focused documentation for components, functions, APIs, and features

Syntax

/sc:document [options] [target]

Options

Flag	Values	Description
--type	inline, external, api, guide	Target format: 'inline' (comments), 'external' (markdown), 'api' (specs), or 'guide'.
--style	brief, detailed	Level of detail: 'brief' (summary) or 'detailed' (full specs).

Examples

Inline documentation

/sc:document --type inline src/utils.ts

API documentation

/sc:document --type api --style detailed api/

User guide

/sc:document --type guide --style brief

/sc:explain

Basic

Provide clear explanations of code, concepts, and system behavior

Syntax

/sc:explain [options] "[target]"

Options

Flag	Values	Description
--level	basic, intermediate, advanced	Target audience expertise: 'basic', 'intermediate', or 'advanced'.
--format	text, examples, interactive	Format of explanation: 'text', 'examples', or 'interactive'.
--context	[domain]	Limits explanation context to a specific domain (e.g., 'auth', 'database').

Examples

Basic explanation

/sc:explain --level basic src/auth/middleware.ts

Advanced detailed explanation

/sc:explain --level advanced --format examples "JWT authentication flow"

Interactive explanation

/sc:explain --format interactive "database optimization"

/sc:index

Basic

Generate comprehensive project documentation and knowledge base

Syntax

/sc:index [options] [target]

Options

Flag	Values	Description
--type	docs, api, structure, readme	Type of index to generate: 'docs', 'api', 'structure', or 'readme'.
--format	md, json, yaml	Format of the result: 'text', 'json', or 'report'.

Examples

Documentation index

/sc:index --type docs

API index

/sc:index --type api --format json api/

Project structure index

/sc:index --type structure --format yaml

Planning & Requirements

4 Commands

/sc:brainstorm

Advanced

Interactive requirements discovery through Socratic dialogue and systematic exploration

Syntax

/sc:brainstorm [options] "[topic/idea]"

Options

Flag	Values	Description
--strategy	systematic, agile, enterprise	Selects the strategic approach: 'systematic' for thoroughness, 'agile' for speed, or 'enterprise' for scale.
--depth	shallow, normal, deep	Controls the depth of analysis: 'shallow' for quick scans, 'deep' for comprehensive reviews.
--parallel	-	Enable parallel exploration paths

Examples

Systematic product discovery (deep analysis)

/sc:brainstorm --strategy systematic --depth deep "AI-powered project management tool"

Agile feature exploration (parallel paths)

/sc:brainstorm --strategy agile --parallel "real-time collaboration features"

Enterprise solution validation

/sc:brainstorm --strategy enterprise "enterprise data analytics platform"

Quick shallow exploration

/sc:brainstorm --depth shallow "mobile app idea"

Systematic parallel deep exploration

/sc:brainstorm --strategy systematic --depth deep --parallel "microservices architecture"

Agile iterative exploration

/sc:brainstorm --strategy agile --depth normal "user authentication improvements"

/sc:design

Basic

Design system architecture, APIs, and component interfaces with comprehensive specifications

Syntax

/sc:design [options] [target]

Options

Flag	Values	Description
--type	architecture, api, component, database	Design type
--format	diagram, spec, code	Format of the result: 'text', 'json', or 'report'.

Examples

System architecture design

/sc:design --type architecture --format diagram user-management-system

API specification design

/sc:design --type api --format spec payment-api

Component interface design

/sc:design --type component --format code notification-service

Database schema design

/sc:design --type database --format diagram e-commerce-db

/sc:estimate

Basic

Provide intelligent development estimates for tasks, features, or projects

Syntax

/sc:estimate [options] "[target]"

Options

Flag	Values	Description
--type	time, effort, complexity	Estimation type
--unit	hours, days, weeks	Time unit
--breakdown	-	Enable detailed breakdown

Examples

Time estimation

/sc:estimate --type time --unit days "authentication system"

Complexity analysis

/sc:estimate --type complexity --breakdown "API refactoring"

/sc:workflow

Advanced

Generate structured implementation workflows from PRDs and feature requirements

Syntax

/sc:workflow [options] "[feature-description]"

Options

Flag	Values	Description
--strategy	systematic, agile, enterprise	Workflow strategy
--depth	shallow, normal, deep	Workflow depth
--parallel	-	Enable parallel execution

Examples

Systematic workflow

/sc:workflow --strategy systematic "payment integration"

Agile iterative workflow

/sc:workflow --strategy agile --depth deep "user onboarding"

Project Management

5 Commands

/sc:pm

Meta

Project Manager Agent - Default orchestration agent that coordinates all sub-agents and manages workflows seamlessly

Syntax

/sc:pm [options] "[request]"

Options

Flag	Values	Description
--strategy	brainstorm, direct, wave	Defines the execution mode: 'brainstorm' for exploratory ideation and requirement discovery through interactive questioning (ideal for vague or unclear requests), 'direct' for immediate implementation without extensive planning (best for clear, well-defined tasks with known scope), or 'wave' for phased rollout with structured implementation stages (optimal for complex multi-phase projects requiring systematic progression). Choose brainstorm when requirements need clarification, direct for straightforward tasks, or wave for large-scale changes.
--verbose	-	Enables detailed logging of internal agent decisions, sub-agent activations, workflow state changes, and delegation patterns. Useful for understanding PM Agent's reasoning process, debugging workflow issues, learning orchestration strategies, or tracking which specialist agents are activated for specific tasks. Provides transparency into strategy selection, task breakdown logic, and execution flow.

Examples

Default usage (no command needed, describe requirements directly, PM Agent handles orchestration automatically)

/sc:pm "Need to add payment processing to the app"

Explicit strategy selection (using wave strategy)

/sc:pm --strategy wave "Improve application security"

Brainstorm mode (PM Agent auto-detects need for exploration)

/sc:pm "Maybe we could improve the user experience?"

Explicit brainstorm strategy (force requirement discovery)

/sc:pm --strategy brainstorm "Add new features to dashboard"

Direct strategy (immediate implementation for clear requirements)

/sc:pm --strategy direct "Fix the login button alignment on mobile"

Verbose mode (track agent orchestration decisions)

/sc:pm --verbose "Refactor the API layer"

Wave strategy with verbose logging (complex project with visibility)

/sc:pm --strategy wave --verbose "Migrate from REST to GraphQL"

Multi-stage project workflow (authentication system)

/sc:pm --strategy wave "Implement complete user authentication with OAuth, 2FA, and session management"

Debugging workflow (performance investigation)

/sc:pm --verbose "Investigate and fix dashboard loading performance issues"

Performance optimization project (systematic improvement)

/sc:pm --strategy wave "Optimize application performance across frontend, backend, and database"

/sc:task

Advanced

Complex task execution with intelligent workflow management and delegation

Syntax

/sc:task [options] "[task-description]"

Options

Flag	Values	Description
--strategy	systematic, agile, enterprise	Defines task execution approach: 'systematic' for methodical step-by-step progression with comprehensive planning and validation at each stage (best for complex, unfamiliar tasks requiring careful analysis), 'agile' for iterative rapid development with frequent validation cycles (ideal for evolving requirements or experimental features), or 'enterprise' for large-scale operations with governance, documentation, and cross-team coordination (suited for mission-critical changes affecting multiple systems). Choose systematic for thoroughness, agile for speed and flexibility, or enterprise for organizational scale.
--parallel	-	Enables parallel execution of independent operations when task can be decomposed into non-dependent subtasks. Automatically identifies opportunities for concurrent processing to reduce total execution time. Particularly effective for multi-file edits, batch operations, or tasks with clear component boundaries. Use when optimizing for speed and operations have no sequential dependencies.
--delegate	-	Enables intelligent delegation to specialized sub-agents based on task domain and complexity. Task agent analyzes requirements and routes subtasks to appropriate specialists (e.g., frontend-architect for UI, security-engineer for auth, performance-engineer for optimization). Use for complex tasks spanning multiple domains or requiring specialized expertise. Enhances quality through expert-level execution.

Examples

Systematic task execution

/sc:task --strategy systematic "implement authentication"

Parallel task execution with delegation

/sc:task --parallel --delegate "refactor API endpoints"

Agile strategy (iterative development)

/sc:task --strategy agile "build interactive data visualization dashboard"

Enterprise strategy (large-scale migration)

/sc:task --strategy enterprise "migrate 50+ microservices to Kubernetes"

Parallel execution (independent operations)

/sc:task --parallel "update all component prop types to TypeScript"

Delegation to specialists (complex domain task)

/sc:task --delegate "implement end-to-end encryption for messaging feature"

Systematic with parallelization (thorough + fast)

/sc:task --strategy systematic --parallel "refactor legacy codebase to modern patterns"

Agile with full delegation and parallelization (rapid multi-domain development)

/sc:task --strategy agile --delegate --parallel "add real-time collaboration features across frontend and backend"

/sc:spawn

Meta

Meta-system task orchestration with intelligent breakdown and delegation

Syntax

/sc:spawn [complex-task] [options]

Options

Flag	Values	Description
--strategy	sequential, parallel, adaptive	Defines task coordination approach: 'sequential' for step-by-step execution where each phase must complete before the next begins (ideal for dependent tasks with strict ordering requirements), 'parallel' for concurrent execution of independent subtasks to maximize speed (best for tasks with clear boundaries and no dependencies), or 'adaptive' for intelligent dynamic routing that analyzes complexity and adjusts strategy automatically (recommended for complex multi-domain projects with mixed dependency patterns). Choose sequential for ordered workflows, parallel for maximum throughput, or adaptive for uncertain complexity.
--depth	normal, deep	Controls task decomposition granularity: 'normal' provides standard breakdown into major phases and components (suitable for most projects with clear structure), 'deep' performs recursive decomposition into fine-grained subtasks with comprehensive dependency analysis (essential for complex legacy systems, architectural migrations, or when thorough planning is critical). Use normal for typical projects, deep for maximum planning detail and risk mitigation.

Examples

Complex feature implementation

/sc:spawn "implement user authentication system"

Large-scale system operation

/sc:spawn --strategy adaptive --depth deep "migrate legacy monolith to microservices"

Cross-domain infrastructure

/sc:spawn "establish CI/CD pipeline with security scanning"

Sequential strategy (ordered workflow)

/sc:spawn --strategy sequential "redesign database schema and migrate production data"

Parallel strategy (independent components)

/sc:spawn --strategy parallel "implement API documentation, client SDKs, and usage analytics simultaneously"

Normal depth (standard planning)

/sc:spawn --depth normal "add multi-language support to application"

Deep depth (comprehensive analysis)

/sc:spawn --depth deep "refactor monolithic application into domain-driven microservices"

Parallel with normal depth (fast standard project)

/sc:spawn --strategy parallel --depth normal "build mobile app for iOS and Android platforms"

Sequential with deep depth (complex ordered migration)

/sc:spawn --strategy sequential --depth deep "modernize legacy COBOL system to cloud-native architecture"

Task Hierarchy Visualization

spawn orchestration creates multi-level breakdown:

Level 1: High-level phases (PM Agent coordination)
  ├─ Level 2: Major components (Task Agent execution)
  │   ├─ Level 3: Specific implementations (Specialist Agents)
  │   └─ Level 4: Granular subtasks (depth=deep only)

Example: "Build e-commerce platform"
  ├─ Phase 1: Architecture & Design
  │   ├─ Database schema design (backend-architect)
  │   ├─ API contracts definition (backend-architect)
  │   └─ UI/UX wireframes (frontend-architect)
  ├─ Phase 2: Core Implementation
  │   ├─ Product catalog (backend + frontend)
  │   ├─ Shopping cart (backend + frontend)
  │   └─ Payment integration (security-engineer + backend)
  └─ Phase 3: Testing & Deployment
      ├─ E2E testing (quality-engineer)
      └─ Production deployment (devops-architect)

/sc:select-tool

Basic

Intelligent MCP tool selection based on complexity scoring and operation analysis

Syntax

/sc:select-tool [options]

Options

Flag	Values	Description
--analyze	-	Performs deep analysis of current project context, task complexity, and available MCP tools to recommend optimal tool selection. Evaluates factors including: codebase size, operation type, performance requirements, and tool capabilities. Outputs complexity score (0-1), recommended tools, and confidence level. Useful for understanding which tools are best suited for your specific scenario before execution.
--explain	-	Provides detailed reasoning and decision logic behind tool selection recommendations. Explains why specific tools were chosen over alternatives, including trade-off analysis, capability matching, and efficiency considerations. Educational mode that helps users learn tool selection patterns and understand the intelligent routing system. Combine with --analyze for comprehensive tool selection education.

Examples

Analyze tool selection

/sc:select-tool --analyze

Explain tool selection reasoning

/sc:select-tool --explain

Combined analysis and explanation (learning mode)

/sc:select-tool --analyze --explain

Performance optimization workflow with tool selection

# Step 1: Analyze optimal tools for performance task
/sc:select-tool --analyze --explain

# Step 2: Use recommended tools for execution
# (Based on analysis: Sequential for profiling, Serena for code navigation)

/sc:index-repo

Basic

Repository indexing for context optimization (94% token reduction: 58K → 3K)

Syntax

/sc:index-repo [path]

Examples

Index current repository

/sc:index-repo .

Index specific directory

/sc:index-repo src/

Large repository with performance metrics

/sc:index-repo .

Incremental re-indexing workflow

# Initial index
/sc:index-repo .

# After significant code changes (e.g., feature branch merge, refactoring)
/sc:index-repo .  # Re-index to update project understanding

# Target specific changed area for faster update
/sc:index-repo src/features/authentication/

Multi-module project indexing strategy

# Monorepo with multiple packages
/sc:index-repo packages/backend/    # Index backend module
/sc:index-repo packages/frontend/   # Index frontend module
/sc:index-repo packages/shared/     # Index shared utilities

# Or index entire monorepo at once
/sc:index-repo .                    # Comprehensive index

Research & Analysis

3 Commands

/sc:research

Advanced

Deep web research with adaptive planning and intelligent search

Syntax

/sc:research [options] "[query]"

Options

Flag	Values	Description
--depth	quick, standard, deep, exhaustive	Depth of search: 'quick' (summary), 'standard', 'deep' (comprehensive), or 'exhaustive'.
--strategy	planning, intent, unified	Research approach: 'planning', 'intent', or 'unified'.

Examples

Basic research (default depth)

/sc:research "latest developments in quantum computing 2024"

Deep competitive analysis

/sc:research --depth deep "competitive analysis of AI coding assistants"

Unified strategy research

/sc:research --strategy unified "best practices for distributed systems"

Quick fact query

/sc:research --depth quick "current React version"

Academic-level deep research

/sc:research --depth exhaustive "machine learning optimization techniques"

Intent planning research

/sc:research --strategy intent "cloud architecture patterns"

Deep + planning combination

/sc:research --depth deep --strategy planning "microservices security best practices"

Standard research (explicit)

/sc:research --depth standard "database scaling strategies"

/sc:business-panel

Advanced

Multi-expert business strategy analysis with 9 renowned business thinkers

Syntax

/sc:business-panel [options] "[topic]"

Options

Flag	Values	Description
--mode	discussion, debate, socratic	Analysis mode
--experts	[name1,name2,...]	Expert selection

Examples

Market entry strategy analysis

/sc:business-panel --mode discussion "market entry strategy"

Debate mode

/sc:business-panel --mode debate --experts porter,godin "pricing strategy"

Socratic exploration

/sc:business-panel --mode socratic "digital transformation"

/sc:spec-panel

Advanced

Multi-expert specification review and improvement with renowned software engineering experts

Syntax

/sc:spec-panel [options] "[specification]"

Options

Flag	Values	Description
--mode	discussion, critique, socratic	Review mode
--experts	[name1,name2,...]	Expert selection
--focus	requirements, architecture, testing, compliance	Review focus
--iterations	[N]	Number of iterations
--format	standard, structured, detailed	Format of the result: 'text', 'json', or 'report'.

Examples

Requirements specification review

/sc:spec-panel --focus requirements "API specification"

Architecture critique mode

/sc:spec-panel --mode critique --focus architecture "microservices design"

Detailed iterative review

/sc:spec-panel --iterations 3 --format detailed "security policy"

Socratic testing review

/sc:spec-panel --mode socratic --focus testing "test coverage strategy"

Compliance discussion review

/sc:spec-panel --mode discussion --focus compliance "GDPR requirements"

Expert-specific architecture review

/sc:spec-panel --experts fowler,beck --focus architecture "domain-driven design"

Multi-round structured requirements review

/sc:spec-panel --iterations 5 --format structured --focus requirements "user stories"

Critique mode testing review (detailed)

/sc:spec-panel --mode critique --focus testing --format detailed "integration tests"

Comprehensive specification review

/sc:spec-panel --mode discussion --focus requirements --iterations 3 --format detailed "system specification"

Session Management

3 Commands

/sc:load

Basic

Session lifecycle management with Serena MCP integration for project context loading

Syntax

/sc:load [target] [options]

Options

Flag	Values	Description
--type	project, config, deps, checkpoint	Load type
--refresh	-	Refresh cache
--analyze	-	Enable analysis

Examples

Load project context

/sc:load --type project src/

Load checkpoint

/sc:load --type checkpoint "auth-feature"

Refresh and analyze

/sc:load --refresh --analyze

/sc:save

Basic

Session lifecycle management with Serena MCP integration for session context persistence

Syntax

/sc:save [name] [options]

Options

Flag	Values	Description
--type	session, learnings, context, all	Save type
--summarize	-	Generate summary
--checkpoint	-	Create checkpoint

Examples

Save session

/sc:save --type session "auth-complete"

Save learnings

/sc:save --type learnings --summarize

Create checkpoint

/sc:save --checkpoint "midpoint"

/sc:agent

Advanced

SC Agent - Session controller that orchestrates the complete workflow of investigation, implementation, and review

Syntax

Examples

Agent starts automatically at session start, takes over complete workflow after user describes task

/sc:agent # No manual invocation required, auto-activated

Testing & Quality

4 Commands

/sc:test

Advanced

Execute tests with coverage analysis and automated quality reporting

Syntax

/sc:test [options] [target]

Options

Flag	Values	Description
--type	unit, integration, e2e, all	Scope of testing: 'unit', 'integration', 'e2e', or 'all'.
--coverage	-	Generates a code coverage report identifying untested lines.
--watch	-	Re-runs tests automatically when file changes are detected.
--fix	-	Attempts to automatically resolve minor test failures like formatting or snapshot mismatches.

Examples

Basic test execution

/sc:test

Unit test coverage analysis

/sc:test --type unit --coverage src/components

End-to-end browser testing

/sc:test --type e2e

Development watch mode (auto-fix)

/sc:test --watch --fix

Integration testing

/sc:test --type integration

Comprehensive testing (with coverage)

/sc:test --type all --coverage

Unit test watch mode

/sc:test --type unit --watch

E2E testing (auto-fix)

/sc:test --type e2e --fix

Coverage watch mode

/sc:test --coverage --watch

/sc:analyze

Basic

Comprehensive code analysis across quality, security, performance, and architecture domains

Syntax

/sc:analyze [options] [target]

Options

Flag	Values	Description
--focus	quality, security, performance, architecture	Domain to analyze: 'quality', 'security', 'performance', or 'architecture'.
--depth	quick, deep	Controls the depth of analysis: 'shallow' for quick scans, 'deep' for comprehensive reviews.
--format	text, json, report	Format of the result: 'text', 'json', or 'report'.

Examples

Comprehensive project analysis

/sc:analyze

Focused security assessment (deep)

/sc:analyze --focus security --depth deep src/auth

Performance optimization analysis (report format)

/sc:analyze --focus performance --format report

Quick quality check

/sc:analyze --focus quality --depth quick src/components

Architecture deep analysis (JSON output)

/sc:analyze --focus architecture --depth deep --format json

Security quick scan

/sc:analyze --focus security --depth quick

Performance deep analysis

/sc:analyze --focus performance --depth deep api/

Quality report (deep)

/sc:analyze --focus quality --depth deep --format report src/

/sc:troubleshoot

Basic

Diagnose and resolve issues in code, builds, deployments, and system behavior

Syntax

/sc:troubleshoot [options] "[issue-description]"

Options

Flag	Values	Description
--type	bug, build, performance, deployment	Category of the issue: 'bug', 'build', 'performance', or 'deployment'.
--trace	-	Outputs detailed execution traces to pinpoint failure origins.
--fix	-	Attempts to automatically apply patches for identified issues.

Examples

Bug diagnosis

/sc:troubleshoot --type bug "login form not submitting"

Build issues

/sc:troubleshoot --type build --trace "build failing on CI"

Performance issues

/sc:troubleshoot --type performance --fix "API response slow"

/sc:reflect

Basic

Task reflection and validation using Serena MCP analysis capabilities

Syntax

/sc:reflect [options] [target]

Options

Flag	Values	Description
--type	task, session, completion	Scope of reflection: 'task' (current item), 'session' (history), or 'completion' (goal check).
--analyze	-	Performs exhaustive reasoning to uncover hidden patterns or risks.
--validate	-	Runs verification steps (e.g., linters, tests) after changes are applied.

Examples

Task reflection

/sc:reflect --type task --analyze

Session review

/sc:reflect --type session

Completion validation

/sc:reflect --type completion --validate

Utilities

2 Commands

/sc:help

Basic

List all available /sc commands and their functionality

Syntax

/sc:help [command-name]

Examples

Show all command help

/sc:help

Specific command help

/sc:help implement

System Guides

MCP Server Integration

Available Servers

Server	Purpose	API Key	Auto-Activation Triggers
context7	Official library documentation	No	Import statements, framework keywords
sequential	Multi-step reasoning	No	`--think`, debugging, complex analysis
magic	UI component generation	Yes	`component`, `UI`, frontend requests
playwright	Browser automation	No	`test`, `e2e`, `browser`
morphllm	Code transformations	Yes	Multi-file edits, refactoring
serena	Semantic code understanding	No	Large projects, session management
tavily	Web search	Yes (free tier)	`/sc:research`, `latest`
chrome-devtools	Performance analysis	No	`performance`, `debug`

Server Combinations

yaml

Free (No API Keys):
  - context7 + sequential + playwright + serena

Learning:
  - context7 + sequential

Web Development:
  - magic + context7 + playwright

Deep Research:
  - tavily + sequential + serena

Enterprise Refactoring:
  - serena + morphllm + sequential

Configuration

MCP servers are configured in ~/.claude.json:

json

{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp@latest"]
    },
    "tavily": {
      "command": "npx",
      "args": ["-y", "tavily-mcp@latest"],
      "env": {"TAVILY_API_KEY": "${TAVILY_API_KEY}"}
    }
  }
}

Best Practices

1. Command Selection Guide

Scenario	Recommended Command	Reason
New project kickoff	`/sc:brainstorm`	Structured requirements discovery
Feature implementation	`/sc:implement`	Intelligent persona coordination
Code review	`/sc:analyze`	Multi-dimensional analysis
Test execution	`/sc:test`	Coverage and quality reporting
Deep research	`/sc:research`	Adaptive multi-source search
Daily tasks	`/sc:pm`	Auto-orchestration (default)

2. Flag Combination Patterns

bash

# Deep security analysis
/sc:analyze --focus security --depth deep

# Comprehensive testing
/sc:test --type all --coverage

# Safe implementation
/sc:implement "feature" --safe --with-tests

# Detailed research
/sc:research "topic" --depth exhaustive --strategy unified

3. Workflow Patterns

New Feature Development:

bash

/sc:brainstorm "feature idea" --strategy systematic
/sc:design "feature" --type architecture
/sc:workflow "implementation plan"
/sc:implement "feature" --with-tests
/sc:test --coverage
/sc:document --type api

Bug Fixing:

bash

/sc:troubleshoot "bug description" --trace
/sc:analyze --focus quality --depth deep
/sc:implement "fix" --safe
/sc:test --type regression

Code Optimization:

bash

/sc:analyze --focus performance
/sc:improve --type performance --safe
/sc:cleanup --type all --interactive
/sc:test --coverage

4. Token Efficiency

Task Complexity	Token Budget	Recommended Approach
Simple (typo)	200	Direct fix
Medium (bug fix)	1,000	Confidence check
Complex (new feature)	2,500	Full workflow

Confidence Check ROI: Spending 100-200 tokens can save 5,000-50,000 tokens

Quick Reference Card

Core Commands

bash

# Discovery & Planning
/sc:brainstorm "idea"        # Structured brainstorming
/sc:design "system"          # Architecture design
/sc:workflow "task"          # Workflow planning

# Development
/sc:implement "feature"      # Code implementation
/sc:improve path/            # Code improvement
/sc:test --coverage          # Test execution

# Research
/sc:research "topic"         # Web research
/sc:analyze path/            # Code analysis

# Session Management
/sc:save "checkpoint"        # Save session
/sc:load "session"           # Load session
/sc                          # List all commands

Common Flags

bash

--think         # Enable sequential reasoning
--think-hard    # Enable deep analysis
--c7            # Force Context7 activation
--no-mcp        # Disable MCP servers
--all-mcp       # Enable all MCP servers
--coverage      # Include test coverage
--depth quick   # Research depth control
--safe          # Safe mode
--with-tests    # Include tests
--interactive   # Interactive mode

Installation & Upgrade

Installation

To install the SuperClaude Framework CLI:

bash

npm install -g @superclaude/cli

Or run via npx:

bash

npx @superclaude/cli init

Upgrade

To upgrade to the latest version:

bash

npm update -g @superclaude/cli

Check version:

bash

/sc:version