SuperClaude/Reference/examples-cookbook.md

SuperClaude Examples Cookbook 🍳

Practical SuperClaude Usage: Real-world examples, working code, and hands-on scenarios that you can copy, paste, and modify for your projects. Each example includes expected outputs, common variations, and troubleshooting tips.

Real-World Focus: These examples come from actual development scenarios - building web applications, API systems, mobile apps, DevOps pipelines, and data analysis projects using SuperClaude's intelligent orchestration.

How to Use This Cookbook

Practical Reference Approach:

• Copy & Adapt: All examples are production-ready - copy them and modify for your needs
• Progressive Complexity: Start with Quick Examples, progress to Real-World Scenarios
• Working Examples: Every command shown has been tested and produces the expected results
• Immediate Trial: Most examples can be tried immediately after SuperClaude installation

Example Structure:

# What it does: Brief description of the example's purpose
/sc:command "description"

# Expected: What SuperClaude will do
# Activates: Which agents/modes/MCP servers activate
# Output: What you'll see and receive

# Variations: Common modifications and alternatives
# Troubleshooting: Common issues and solutions

Navigation Guide:

• New to SuperClaude: Start with Quick Examples
• Learning Project Workflows: Jump to Project Workflow Examples
• Specific Commands: Use Command Examples by Category
• Complex Scenarios: Skip to Real-World Scenarios

Quick Examples

Essential One-Liners for Immediate Results:

# Interactive project discovery and requirements gathering
/sc:brainstorm "mobile app for fitness tracking"
# Activates: Brainstorming mode + system-architect + requirements-analyst + Context7
# Expected: Socratic dialogue, requirement elicitation, feasibility analysis

# Analyze existing codebase for issues and improvements
/sc:analyze src/ --focus security
# Activates: security-engineer + quality-engineer + performance-engineer
# Expected: Comprehensive security audit, vulnerability report, improvement suggestions

# Implement a complete feature with best practices
/sc:implement "user authentication with JWT and rate limiting"
# Activates: security-engineer + backend-architect + Context7 + quality gates
# Expected: Complete auth implementation, security validation, tests included

# Troubleshoot and fix a problem systematically
/sc:troubleshoot "API returns 500 error on user login"
# Activates: root-cause-analyst + Sequential reasoning + systematic debugging
# Expected: Step-by-step diagnosis, root cause identification, solution ranking

# Generate comprehensive tests for existing code
/sc:test --type e2e --coverage
# Activates: quality-engineer + Playwright MCP + test automation
# Expected: End-to-end test suite, coverage report, quality metrics

Basic Usage Patterns:

# Discovery Pattern: From idea to requirements
/sc:brainstorm → /sc:workflow → /sc:design

# Development Pattern: From requirements to code  
/sc:design → /sc:implement → /sc:test

# Quality Pattern: From code to production-ready
/sc:analyze → /sc:improve → /sc:cleanup → /sc:test

# Learning Pattern: From confusion to understanding
/sc:explain → /sc:document → /sc:examples

Getting Started Examples

First Day with SuperClaude

Example 1: Your First Project Analysis

# What it does: Understand an existing project structure and codebase
/sc:load . && /sc:analyze --comprehensive

# Expected: 
# - Project structure analysis and documentation
# - Code quality assessment across all files
# - Architecture overview with component relationships
# - Security audit and performance recommendations

# Activates: Serena (project loading) + analyzer + security-engineer + performance-engineer
# Output: Comprehensive project report with actionable insights

# Common variations:
/sc:analyze src/ --focus quality          # Focus on code quality only
/sc:analyze . --scope file --depth shallow  # Quick analysis of specific files
/sc:analyze backend/ --focus security --export html  # Security report for backend

Example 2: Interactive Requirements Discovery

# What it does: Transform a vague idea into concrete requirements
/sc:brainstorm "productivity app for remote teams"

# Expected:
# - Socratic questioning about user needs and pain points
# - Feature prioritization and scope definition
# - Technical feasibility assessment
# - Structured requirements document generation

# Activates: Brainstorming mode + system-architect + requirements-analyst
# Output: Product Requirements Document (PRD) with clear specifications

# Follow-up commands:
/sc:workflow "team collaboration features"  # Generate implementation plan
/sc:design "real-time messaging system"     # Design system architecture

Learning Progression Examples

Beginner Level: Single Commands

# Explain code concepts clearly
/sc:explain "async/await in JavaScript" --level beginner --examples
# Activates: learning-guide + educational focus
# Expected: Step-by-step explanation with practical examples

# Document existing code
/sc:document src/components/ --style user-guide --audience developers
# Activates: technical-writer + documentation generation
# Expected: Comprehensive API documentation with usage examples

# Simple code improvements
/sc:improve utils.py --type readability --preview
# Activates: refactoring-expert + code quality focus
# Expected: Readability improvements with preview before applying

Intermediate Level: Command Combinations

# Complete feature development workflow
/sc:design "payment processing system" && /sc:implement "Stripe integration" && /sc:test --coverage

# Quality assurance workflow  
/sc:analyze --focus quality && /sc:improve --safe-mode && /sc:cleanup --comprehensive

# Debugging workflow
/sc:troubleshoot "slow database queries" && /sc:analyze db/ --focus performance && /sc:improve --type performance

Advanced Level: Session Management

# Long-term project development with session persistence
/sc:load "ecommerce-project" && /sc:save "checkpoint-auth-complete"

# Cross-session context building
/sc:reflect "payment integration completed" && /sc:workflow "shipping system next"

# Multi-agent coordination
/sc:spawn "complete microservices platform" --parallel --monitor

Project Workflow Examples

Complete E-Commerce Platform Development

Phase 1: Discovery & Planning

# Initial project brainstorming
/sc:brainstorm "e-commerce platform for small businesses"
# Expected: Requirements discovery, feature prioritization, technical scope

# Save initial session context
/sc:save "ecommerce-requirements-complete"

# Generate implementation workflow
/sc:workflow "MVP e-commerce with user management, product catalog, and payments"
# Expected: Structured development plan with phases, dependencies, and timelines

# System architecture design
/sc:design "microservices architecture for e-commerce" --type system --format mermaid
# Expected: Service boundaries, data flow diagrams, technology recommendations

Phase 2: Core Implementation

# Load previous session
/sc:load "ecommerce-requirements-complete"

# User management system
/sc:implement "user registration and authentication with JWT"
# Activates: security-engineer + backend-architect + Context7
# Expected: Complete auth system with security best practices

# Product catalog implementation
/sc:implement "product management REST API with search and filtering"
# Activates: backend-architect + database specialist + API design patterns
# Expected: Scalable product API with performance optimization

# Frontend development
/sc:implement "React product catalog with responsive design"
# Activates: frontend-architect + Magic MCP + accessibility compliance
# Expected: Modern React components with accessibility and responsive design

Phase 3: Integration & Testing

# Integration testing
/sc:test --type integration --focus api-frontend
# Activates: quality-engineer + Playwright MCP + integration scenarios
# Expected: Comprehensive integration test suite with API-frontend validation

# Performance optimization
/sc:analyze . --focus performance && /sc:improve --type performance --measure-impact
# Expected: Performance bottleneck identification and optimization with impact measurement

# Security audit
/sc:analyze . --focus security --depth deep --export report
# Expected: Comprehensive security assessment with vulnerability reporting

API Development Project Workflow

Complete REST API with Authentication

# Project initialization and design
/sc:brainstorm "REST API for task management" && /sc:design "RESTful task API" --type api --format openapi

# Core API implementation
/sc:implement "Express.js REST API with CRUD operations for tasks"
# Expected: Complete Express.js API with proper routing, validation, error handling

# Authentication layer
/sc:implement "JWT authentication middleware with rate limiting"
# Expected: Secure authentication with rate limiting and token management

# Database integration
/sc:implement "PostgreSQL integration with connection pooling"
# Expected: Database layer with connection management and query optimization

# API documentation
/sc:document api/ --type api --format swagger --include-examples
# Expected: Comprehensive API documentation with examples and usage guidelines

# Testing and validation
/sc:test --type unit --coverage && /sc:test --type integration --api-validation
# Expected: Complete test suite with unit and integration coverage

Frontend Application Workflow

React Dashboard Development

# Design system planning
/sc:design "admin dashboard component architecture" --type frontend

# Component implementation
/sc:implement "React dashboard with charts and data tables"
# Activates: frontend-architect + Magic MCP + data visualization patterns
# Expected: Modern dashboard with interactive components

# State management
/sc:implement "Redux state management for dashboard data"
# Expected: Proper state management with actions, reducers, and selectors

# Accessibility compliance
/sc:improve src/components/ --focus accessibility --validate-wcag
# Expected: Accessibility improvements with WCAG compliance validation

# Performance optimization
/sc:analyze src/ --focus performance && /sc:improve --type performance --bundle-analysis
# Expected: Bundle optimization and performance improvements

DevOps Pipeline Workflow

CI/CD Pipeline Setup

# Infrastructure design
/sc:design "CI/CD pipeline for Node.js microservices" --type infrastructure

# Docker containerization
/sc:implement "Docker containers for microservices deployment"
# Activates: devops-architect + containerization best practices
# Expected: Production-ready Docker setup with multi-stage builds

# GitHub Actions workflow
/sc:implement "GitHub Actions pipeline with testing and deployment"
# Expected: Automated CI/CD pipeline with quality gates

# Monitoring setup
/sc:implement "application monitoring with Prometheus and Grafana"
# Expected: Comprehensive monitoring and alerting system

# Security hardening
/sc:analyze infrastructure/ --focus security && /sc:improve --type security --compliance
# Expected: Security hardening with compliance validation

Best Practice Workflow Patterns

Quality-First Development Pattern:

# Every feature follows this pattern:
/sc:design "feature specification" → /sc:implement "feature code" → /sc:test --comprehensive → /sc:analyze --focus quality → /sc:improve --safe-mode → /sc:document "feature documentation"

Security-Focused Development Pattern:

# Security considerations at every step:
/sc:brainstorm "feature with security focus" → /sc:design --security-first → /sc:implement --security-validation → /sc:analyze --focus security → /sc:test --security-scenarios

Performance-Oriented Development Pattern:

# Performance optimization workflow:
/sc:analyze --focus performance --baseline → /sc:implement "optimized solution" → /sc:test --performance-benchmarks → /sc:improve --type performance --measure-impact

Command Examples by Category

Analysis Examples

Code Quality Analysis:

# Comprehensive codebase analysis
/sc:analyze . --comprehensive --export html
# Activates: quality-engineer + security-engineer + performance-engineer
# Output: Multi-domain analysis report in HTML format
# Use case: Pre-deployment quality review, code review preparation

# Focused security audit
/sc:analyze src/ --focus security --depth deep --include-dependencies
# Activates: security-engineer + vulnerability assessment + dependency analysis
# Output: Security vulnerabilities, compliance issues, dependency risks
# Use case: Security compliance review, penetration testing preparation

# Performance bottleneck identification
/sc:analyze api/ --focus performance --profile --memory-analysis
# Activates: performance-engineer + profiling tools + memory analysis
# Output: Performance hotspots, memory usage patterns, optimization opportunities
# Use case: Performance optimization, scalability planning

# Architecture review
/sc:analyze . --focus architecture --dependencies --coupling-analysis
# Activates: system-architect + dependency analysis + design pattern assessment
# Output: Architecture overview, coupling metrics, design pattern usage
# Use case: Technical debt assessment, refactoring planning

Language-Specific Analysis:

# Python-specific analysis
/sc:analyze **/*.py --focus quality --include-type-hints --pep8-compliance
# Expected: Python code quality with type safety and style compliance

# JavaScript/TypeScript analysis
/sc:analyze src/ --focus quality --include-bundle-analysis --dependencies
# Expected: Frontend code quality with bundle size and dependency analysis

# Multi-language project analysis
/sc:analyze . --focus architecture --cross-language-dependencies
# Expected: Cross-language architecture analysis with interface compatibility

Implementation Examples

Full-Stack Feature Implementation:

# Complete authentication system
/sc:implement "full-stack authentication with React frontend and Node.js backend"
# Activates: frontend-architect + backend-architect + security-engineer + Context7 + Magic
# Expected: Complete auth system with frontend components, backend API, security validation
# Output: React login/register components, JWT middleware, password security, session management

# Real-time chat feature
/sc:implement "real-time chat with WebSocket and message persistence"
# Activates: backend-architect + frontend-architect + database specialist + real-time patterns
# Expected: WebSocket implementation, message storage, real-time UI updates
# Output: Socket.io server, React chat interface, message history API

# Payment processing integration
/sc:implement "Stripe payment integration with subscription management"
# Activates: backend-architect + security-engineer + Context7 (Stripe patterns)
# Expected: Secure payment processing with webhook handling and subscription logic
# Output: Payment API, webhook handlers, subscription management, security compliance

API Development:

# RESTful API with documentation
/sc:implement "REST API for blog management with OpenAPI documentation"
# Activates: backend-architect + technical-writer + API design patterns
# Expected: Complete REST API with proper HTTP methods, status codes, documentation
# Output: Express.js routes, validation middleware, OpenAPI spec, API documentation

# GraphQL API implementation
/sc:implement "GraphQL API with schema-first design and resolvers"
# Activates: backend-architect + Context7 (GraphQL patterns) + type safety
# Expected: GraphQL schema, resolvers, type definitions, query optimization
# Output: GraphQL server, schema definitions, resolver functions, type safety

# Microservices communication
/sc:implement "microservices communication with message queues and service discovery"
# Activates: system-architect + devops-architect + distributed systems patterns
# Expected: Inter-service communication, message queuing, service registration
# Output: RabbitMQ/Redis setup, service discovery, API gateway configuration

Frontend Implementation:

# Modern React application
/sc:implement "React application with TypeScript, state management, and routing"
# Activates: frontend-architect + Magic MCP + TypeScript patterns + Context7
# Expected: Complete React setup with modern patterns and tooling
# Output: TypeScript configuration, Redux/Zustand setup, React Router, component structure

# Responsive design system
/sc:implement "component library with Storybook and accessibility compliance"
# Activates: frontend-architect + Magic MCP + accessibility validation + design systems
# Expected: Reusable component library with documentation and accessibility
# Output: Styled components, Storybook stories, accessibility tests, design tokens

# Progressive Web App
/sc:implement "PWA with offline capabilities and push notifications"
# Activates: frontend-architect + PWA patterns + service worker implementation
# Expected: Service worker setup, offline functionality, notification system
# Output: PWA manifest, service worker, offline storage, notification handlers

Quality Examples

Testing Implementation:

# Comprehensive test suite
/sc:test --type all --coverage --report
# Activates: quality-engineer + Playwright MCP + test automation
# Expected: Unit, integration, and E2E tests with coverage reporting
# Output: Jest unit tests, Cypress E2E tests, coverage reports, quality metrics

# Performance testing
/sc:test --type performance --load-testing --benchmark
# Activates: performance-engineer + load testing tools + benchmarking
# Expected: Load testing scenarios with performance benchmarks
# Output: Load test results, performance metrics, bottleneck identification

# Security testing
/sc:test --type security --penetration --vulnerability-scan
# Activates: security-engineer + security testing tools + vulnerability assessment
# Expected: Security test scenarios with vulnerability scanning
# Output: Security test results, vulnerability reports, compliance validation

# Accessibility testing
/sc:test --type accessibility --wcag-compliance --screen-reader
# Activates: quality-engineer + accessibility validation + compliance testing
# Expected: Accessibility test scenarios with WCAG compliance validation
# Output: Accessibility reports, compliance status, remediation suggestions

Code Quality Improvement:

# Systematic code improvement
/sc:improve src/ --type comprehensive --safe-mode --backup
# Activates: refactoring-expert + quality-engineer + safety validation
# Expected: Code quality improvements with safety guarantees
# Output: Refactored code, improvement reports, backup creation

# Performance optimization
/sc:improve api/ --type performance --measure-impact --before-after
# Activates: performance-engineer + benchmarking + impact measurement
# Expected: Performance improvements with measurable impact
# Output: Optimized code, performance comparisons, impact analysis

# Security hardening
/sc:improve . --type security --compliance-check --vulnerability-fix
# Activates: security-engineer + compliance validation + vulnerability remediation
# Expected: Security improvements with compliance validation
# Output: Hardened code, security reports, compliance status

Troubleshooting Examples

Systematic Problem Diagnosis:

# API performance issues
/sc:troubleshoot "API response time increased from 200ms to 2 seconds"
# Activates: root-cause-analyst + performance-engineer + Sequential reasoning
# Expected: Systematic diagnosis with hypothesis testing and root cause identification
# Output: Problem analysis, root cause, solution ranking, implementation plan

# Database connection problems
/sc:troubleshoot "database connection pool exhausted under load"
# Activates: root-cause-analyst + database specialist + performance analysis
# Expected: Connection pool analysis, load testing, configuration recommendations
# Output: Database diagnostics, configuration fixes, scaling recommendations

# Frontend rendering issues
/sc:troubleshoot "React components causing memory leaks and slow rendering"
# Activates: root-cause-analyst + frontend-architect + performance analysis
# Expected: Memory leak detection, rendering optimization, component analysis
# Output: Memory analysis, component fixes, performance improvements

Build and Deployment Issues:

# Build pipeline failures
/sc:troubleshoot "CI/CD pipeline failing at Docker build stage"
# Activates: root-cause-analyst + devops-architect + build system analysis
# Expected: Build process analysis, dependency resolution, configuration fixes
# Output: Build diagnostics, Dockerfile fixes, pipeline optimization

# Production deployment problems
/sc:troubleshoot "application crashes after deployment with 502 errors"
# Activates: root-cause-analyst + devops-architect + system diagnostics
# Expected: Production environment analysis, log analysis, system configuration
# Output: Deployment diagnostics, configuration fixes, monitoring setup

# Performance degradation after deployment
/sc:troubleshoot "application performance degraded 300% after latest deployment"
# Activates: root-cause-analyst + performance-engineer + deployment analysis
# Expected: Performance regression analysis, code comparison, optimization plan
# Output: Performance analysis, regression identification, rollback/fix plan

Agent Examples

Multi-Agent Collaboration Patterns

Full-Stack Development Team:

# E-commerce platform requiring multiple specialists
/sc:implement "secure e-commerce platform with payment processing and admin dashboard"

# Automatic agent activation:
# - frontend-architect: Dashboard UI components and user interface
# - backend-architect: API design, database schema, server logic  
# - security-engineer: Payment security, authentication, data protection
# - devops-architect: Deployment, scaling, monitoring setup
# - quality-engineer: Testing strategy, validation, compliance

# Expected coordination:
# 1. security-engineer establishes security requirements and patterns
# 2. backend-architect designs API with security validation
# 3. frontend-architect creates UI components with security compliance
# 4. devops-architect plans secure deployment and monitoring
# 5. quality-engineer validates all security and functionality requirements

Performance Optimization Team:

# Complex performance problem requiring systematic analysis
/sc:troubleshoot "microservices platform experiencing latency spikes under load"

# Automatic agent activation:
# - root-cause-analyst: Systematic problem investigation and hypothesis testing
# - performance-engineer: Performance profiling, bottleneck identification
# - system-architect: Architecture analysis, service communication patterns
# - devops-architect: Infrastructure analysis, scaling recommendations

# Coordination workflow:
# 1. root-cause-analyst leads systematic investigation methodology
# 2. performance-engineer provides technical performance analysis
# 3. system-architect evaluates architectural bottlenecks
# 4. devops-architect recommends infrastructure optimizations

Learning and Documentation Team:

# Complex technical documentation requiring multiple perspectives
/sc:document "microservices architecture guide" --audience mixed --comprehensive

# Automatic agent activation:
# - technical-writer: Documentation structure, clarity, audience targeting
# - system-architect: Technical accuracy, architectural patterns
# - learning-guide: Educational progression, concept explanation
# - quality-engineer: Completeness validation, example verification

# Collaboration pattern:
# 1. learning-guide establishes educational flow and skill progression
# 2. system-architect provides technical accuracy and depth
# 3. technical-writer ensures clarity and audience appropriateness
# 4. quality-engineer validates completeness and example accuracy

Agent Specialization Examples

Security-Focused Development:

# Security agent leading with other agents supporting
/sc:implement "OAuth 2.0 authentication with PKCE and security best practices"

# Primary: security-engineer
# - Threat modeling and security requirement specification
# - Security pattern selection and implementation guidance
# - Vulnerability assessment and compliance validation

# Supporting: backend-architect
# - Technical implementation of security patterns
# - Database security and session management
# - API security and rate limiting implementation

# Integration: Context7 MCP
# - Official OAuth 2.0 documentation and patterns
# - Security library recommendations and usage examples

Performance-Centric Development:

# Performance engineer leading optimization effort
/sc:improve api/ --focus performance --measure-impact

# Primary: performance-engineer
# - Performance profiling and bottleneck identification
# - Optimization strategy development and implementation
# - Performance impact measurement and validation

# Supporting: backend-architect
# - Code-level optimization implementation
# - Database query optimization and caching strategies
# - Architecture modifications for performance

# Supporting: devops-architect
# - Infrastructure performance optimization
# - Scaling strategies and resource allocation
# - Monitoring and alerting for performance metrics

Mode Examples

Brainstorming Mode Scenarios

Interactive Requirements Discovery:

# Vague project idea triggering brainstorming mode
/sc:brainstorm "something for team productivity"

# Mode activation: Brainstorming mode automatically detected
# Behavioral changes:
# - Socratic questioning approach
# - Non-presumptive dialogue style
# - Collaborative exploration focus
# - Requirements elicitation techniques

# Expected interaction flow:
# 1. "What specific productivity challenges does your team face?"
# 2. "Who are the primary users and what are their daily workflows?"
# 3. "What solutions have you tried before and what worked/didn't work?"
# 4. "What would success look like for this productivity solution?"
# 5. Generated structured requirements document

Creative Problem Solving:

# Uncertainty keywords triggering exploration mode
/sc:brainstorm "maybe we could improve our deployment process somehow"

# Mode characteristics:
# - Exploration-focused questioning
# - Alternative solution generation
# - Feasibility assessment for multiple approaches
# - Creative thinking and innovative solutions

# Typical progression:
# DevOps exploration → Current process analysis → Pain point identification → 
# Solution brainstorming → Feasibility assessment → Implementation roadmap

Task Management Mode Scenarios

Complex Multi-Step Projects:

# Large scope triggering task management mode
/sc:implement "complete microservices platform with authentication, API gateway, service mesh, and monitoring"

# Mode activation: >3 steps, multiple domains, complex dependencies
# Behavioral changes:
# - Hierarchical task breakdown (Plan → Phase → Task → Todo)
# - Progress tracking with TodoWrite integration
# - Session persistence and checkpointing
# - Cross-session context maintenance

# Task hierarchy creation:
# Plan: Complete microservices platform
# ├─ Phase 1: Core infrastructure (auth, API gateway)
# ├─ Phase 2: Service mesh and communication
# ├─ Phase 3: Monitoring and observability
# └─ Phase 4: Integration testing and deployment

Long-Term Project Development:

# Multi-session project requiring persistent memory
/sc:load "ecommerce-platform" && /sc:task "implement shopping cart functionality"

# Mode characteristics:
# - Session context restoration and building
# - Memory-driven decision making
# - Progressive feature development
# - Cross-session learning and adaptation

# Memory integration:
# - Previous decisions and architectural choices
# - Component relationships and dependencies
# - Quality standards and testing approaches
# - Performance requirements and constraints

Orchestration Mode Scenarios

High-Complexity Coordination:

# Complex task requiring multiple tools and parallel execution
/sc:spawn "full-stack application with React frontend, Node.js API, PostgreSQL database, Redis caching, Docker deployment, and comprehensive testing"

# Mode activation: Complexity score >0.8, multiple domains, parallel opportunities
# Behavioral changes:
# - Intelligent tool selection and coordination
# - Parallel task execution where possible
# - Resource optimization and efficiency focus
# - Multi-agent workflow orchestration

# Orchestration pattern:
# Parallel Track 1: Frontend development (frontend-architect + Magic MCP)
# Parallel Track 2: Backend development (backend-architect + Context7)
# Parallel Track 3: Database design (database specialist)
# Integration Phase: System integration and testing
# Deployment Phase: DevOps implementation

Token Efficiency Mode Scenarios

Large-Scale Analysis with Resource Constraints:

# Context usage >75% triggering efficiency mode
/sc:analyze large-codebase/ --comprehensive --uc

# Mode activation: --uc flag or resource pressure detected
# Behavioral changes:
# - Symbol-enhanced communication (30-50% token reduction)
# - Compressed clarity with ≥95% information preservation
# - Structured output with bullet points and tables
# - Essential information focus

# Example compressed output:
# ⚡ perf analysis: 
# ├─ API slow ∵ O(n²) algo auth.js:45
# ├─ DB bottleneck → indexing needed users table
# └─ 🧠 memory leak: React components not cleanup

Session Examples

Session Lifecycle Management

Project Initialization and Context Building:

# Starting new project with context establishment
/sc:load new-project/ --initialize
# Expected: Project structure analysis, initial context creation, session establishment

# Building project context through analysis
/sc:analyze . --comprehensive && /sc:save "initial-analysis-complete"
# Expected: Complete project understanding saved for future sessions

# Resuming work with context restoration
/sc:load "initial-analysis-complete" && /sc:reflect
# Expected: Context restoration, progress assessment, next steps identification

Long-Term Development Sessions:

# Phase-based development with checkpointing
/sc:load "ecommerce-project" 

# Authentication phase
/sc:implement "JWT authentication system" && /sc:save "auth-phase-complete"

# Product catalog phase  
/sc:load "auth-phase-complete" && /sc:implement "product catalog API" && /sc:save "catalog-phase-complete"

# Payment integration phase
/sc:load "catalog-phase-complete" && /sc:implement "Stripe payment integration" && /sc:save "payment-phase-complete"

# Each phase builds on previous context while maintaining session continuity

Cross-Session Learning and Adaptation:

# Session with decision tracking and learning
/sc:load "microservices-project" && /sc:reflect "previous payment integration decisions"

# Expected behavior:
# - Recall previous architectural decisions about payment processing
# - Apply learned patterns to new payment features
# - Suggest improvements based on previous implementation experience
# - Maintain consistency with established patterns and standards

Session Memory Patterns

Decision Memory and Consistency:

# Architectural decision recording
/sc:design "authentication system" && /sc:save "auth-architecture-decided"

# Later consistency checking
/sc:load "auth-architecture-decided" && /sc:implement "user registration endpoint"
# Expected: Implementation consistent with previously decided architecture patterns

Progress Tracking and Continuity:

# Multi-day development with progress tracking
Day 1: /sc:implement "user management" && /sc:save "day1-user-mgmt"
Day 2: /sc:load "day1-user-mgmt" && /sc:implement "product catalog" && /sc:save "day2-catalog" 
Day 3: /sc:load "day2-catalog" && /sc:implement "shopping cart" && /sc:save "day3-cart"

# Each day builds on previous work with full context awareness

Flag Examples

Performance and Efficiency Flags

Resource Optimization:

# Ultra-compressed mode for large operations
/sc:analyze massive-codebase/ --uc --scope project
# Activates: Token efficiency mode, symbol communication, 30-50% token reduction
# Expected: Compressed but complete analysis with symbol-enhanced communication

# Concurrency control for parallel operations
/sc:implement "microservices suite" --concurrency 3 --parallel
# Expected: Maximum 3 concurrent operations, intelligent parallel execution

# Focus area limitation for targeted analysis
/sc:analyze . --focus security --scope module
# Expected: Security-focused analysis limited to module scope for efficiency

Analysis Depth Control:

# Standard analysis with moderate depth
/sc:analyze src/ --think
# Activates: Sequential MCP for structured analysis (~4K tokens)
# Expected: Comprehensive but focused analysis with clear structure

# Deep analysis for complex problems
/sc:analyze architecture/ --think-hard --focus architecture
# Activates: Sequential + Context7 for deep analysis (~10K tokens)
# Expected: Detailed architectural analysis with pattern recognition

# Maximum depth for critical system analysis
/sc:analyze . --ultrathink --all-mcp
# Activates: All MCP servers, maximum analysis depth (~32K tokens)
# Expected: Comprehensive system analysis with all available intelligence

Tool Integration Flags

MCP Server Coordination:

# Documentation-focused development
/sc:implement "React component library" --c7 --magic
# Activates: Context7 for official patterns + Magic for UI generation
# Expected: React components following official patterns with modern UI

# Complex analysis requiring multiple reasoning approaches
/sc:troubleshoot "distributed system performance" --seq --c7 --serena
# Activates: Sequential reasoning + Context7 docs + Serena memory
# Expected: Systematic analysis with official patterns and session memory

# Comprehensive development with all capabilities
/sc:implement "enterprise application" --all-mcp
# Activates: All MCP servers for maximum capability
# Expected: Full-featured implementation with all available intelligence

Safety and Validation Flags:

# Safe development with comprehensive validation
/sc:improve legacy-code/ --safe-mode --validate --backup
# Activates: Maximum safety, validation gates, automatic backups
# Expected: Risk-assessed improvements with rollback capability

# Production-ready development with quality gates
/sc:implement "payment processing" --validate --safe-mode --test-required
# Activates: Pre-execution validation, safety checks, mandatory testing
# Expected: Production-ready implementation with comprehensive validation

# Development with risk assessment
/sc:spawn "system redesign" --validate --iterations 3 --safe-mode
# Activates: Risk assessment, iterative improvement, conservative execution
# Expected: Systematic redesign with risk mitigation and iterative validation

Real-World Scenarios

Scenario 1: Startup MVP Development

Context: Early-stage startup needs to build and deploy an MVP for a social media platform within 6 weeks.

Complete Workflow:

# Week 1: Discovery and Architecture
/sc:brainstorm "social media platform for creators" --strategy systematic
# Expected: Requirements discovery, user personas, feature prioritization

/sc:design "social media platform architecture" --type system --scalable
# Expected: Microservices architecture, technology stack, deployment strategy

/sc:workflow "MVP social platform" --strategy agile --timeline 6weeks
# Expected: Sprint planning, development phases, milestone definitions

/sc:save "mvp-planning-complete"

# Week 2-3: Core Implementation
/sc:load "mvp-planning-complete"

/sc:implement "user authentication and profiles with social login"
# Activates: security-engineer + backend-architect + frontend-architect + Context7
# Expected: OAuth integration, user profiles, secure authentication

/sc:implement "content posting and feed with real-time updates"
# Activates: backend-architect + frontend-architect + real-time patterns
# Expected: Content management, real-time feed, WebSocket implementation

/sc:test --type integration --coverage && /sc:save "core-features-complete"

# Week 4-5: Advanced Features and Polish
/sc:load "core-features-complete"

/sc:implement "content recommendation algorithm and social interactions"
# Expected: Recommendation engine, likes/comments, user engagement features

/sc:improve . --focus performance --mobile-optimization
# Expected: Mobile-responsive design, performance optimization

/sc:analyze . --focus security --deployment-ready
# Expected: Security audit, production readiness assessment

# Week 6: Deployment and Launch
/sc:implement "production deployment with monitoring and analytics"
# Activates: devops-architect + monitoring setup + analytics integration
# Expected: Production deployment, monitoring dashboards, user analytics

/sc:test --type e2e --production-simulation
# Expected: End-to-end testing in production-like environment

/sc:document . --type user-guide --launch-ready
# Expected: User documentation, API docs, deployment guides

Scenario 2: Legacy System Modernization

Context: Enterprise company needs to modernize a 10-year-old monolithic application to microservices architecture.

Comprehensive Modernization Workflow:

# Phase 1: Legacy System Analysis
/sc:load legacy-system/ --comprehensive-analysis

/sc:analyze . --focus architecture --legacy-assessment --technical-debt
# Activates: system-architect + refactoring-expert + technical debt analysis
# Expected: Legacy architecture analysis, technical debt assessment, modernization roadmap

/sc:troubleshoot "performance bottlenecks and scalability issues"
# Expected: Performance analysis, scalability constraints, optimization opportunities

/sc:save "legacy-analysis-complete"

# Phase 2: Modernization Strategy
/sc:load "legacy-analysis-complete"

/sc:design "microservices architecture migration strategy" --type system --enterprise
# Activates: system-architect + enterprise patterns + migration strategies
# Expected: Service decomposition plan, data migration strategy, API design

/sc:workflow "legacy to microservices migration" --strategy enterprise --risk-management
# Expected: Phased migration plan, risk mitigation, rollback strategies

/sc:save "modernization-strategy-complete"

# Phase 3: Incremental Migration
/sc:load "modernization-strategy-complete"

# Extract first microservice
/sc:implement "user management microservice extraction" --legacy-integration
# Expected: User service extraction, API compatibility, data synchronization

/sc:test --type integration --legacy-compatibility
# Expected: Integration testing with legacy system, compatibility validation

# Extract second microservice
/sc:implement "payment processing microservice" --security-focus --legacy-data-migration
# Expected: Payment service extraction, secure data migration, transaction integrity

# Continue incremental extraction
/sc:implement "product catalog microservice" --data-consistency --api-versioning
# Expected: Catalog service, data consistency, API versioning strategy

/sc:save "microservices-phase1-complete"

# Phase 4: Infrastructure Modernization
/sc:load "microservices-phase1-complete"

/sc:implement "containerization and orchestration with Kubernetes"
# Activates: devops-architect + containerization + orchestration patterns
# Expected: Docker containers, Kubernetes deployment, service mesh

/sc:implement "CI/CD pipeline for microservices" --enterprise-grade
# Expected: Automated pipeline, quality gates, deployment automation

/sc:implement "monitoring and observability stack"
# Expected: Distributed tracing, metrics collection, log aggregation

# Phase 5: Performance and Security
/sc:analyze microservices/ --focus performance --distributed-systems
# Expected: Performance analysis, distributed system optimization

/sc:analyze . --focus security --enterprise-compliance
# Expected: Security audit, compliance validation, vulnerability assessment

/sc:improve . --type performance --distributed-optimization
# Expected: Performance optimization for distributed architecture

/sc:test --type performance --load-testing --enterprise-scale
# Expected: Load testing, scalability validation, performance benchmarks

Scenario 3: Open Source Project Contribution

Context: Contributing a major feature to a popular open source project with strict quality standards.

Open Source Contribution Workflow:

# Understanding the Project
/sc:load open-source-project/ --contributor-onboarding

/sc:analyze . --focus architecture --contributing-guidelines
# Expected: Architecture understanding, contribution guidelines, code standards

/sc:explain "project architecture and patterns" --contributor-perspective
# Expected: Architecture explanation, pattern documentation, contribution guidance

# Feature Planning
/sc:brainstorm "new feature proposal" --community-focused --open-source
# Expected: Community-oriented feature planning, RFC preparation

/sc:design "feature implementation" --open-source-standards --backward-compatible
# Expected: Feature design following project standards, compatibility considerations

# Implementation with Quality Focus
/sc:implement "feature implementation" --open-source-quality --comprehensive-testing
# Activates: All quality agents + comprehensive validation + community standards
# Expected: High-quality implementation with thorough testing

/sc:test --type comprehensive --coverage-100 --edge-cases
# Expected: Complete test coverage, edge case handling, quality validation

/sc:document feature/ --type contributor --community-guidelines
# Expected: Comprehensive documentation following community standards

# Community Integration
/sc:analyze . --focus compatibility --breaking-changes --community-impact
# Expected: Compatibility analysis, impact assessment, community considerations

/sc:improve . --type maintainability --long-term-support
# Expected: Maintainability improvements, long-term support considerations

/sc:test --type integration --ecosystem-compatibility
# Expected: Ecosystem integration testing, compatibility validation

Advanced Examples

Expert-Level Multi-Tool Coordination

Complex System Performance Optimization:

# Advanced performance optimization requiring all capabilities
/sc:analyze distributed-system/ --ultrathink --all-mcp --focus performance

# Activates comprehensive analysis:
# - Sequential MCP: Multi-step reasoning for complex performance analysis
# - Context7 MCP: Performance patterns and optimization documentation
# - Serena MCP: Project memory and historical performance data
# - Morphllm MCP: Code transformation for optimization patterns
# - Playwright MCP: Performance testing and validation
# - Magic MCP: UI performance optimization (if applicable)

# Expected comprehensive output:
# 1. Systematic performance analysis with bottleneck identification
# 2. Official optimization patterns and best practices
# 3. Historical performance trends and regression analysis
# 4. Automated code optimizations where applicable
# 5. Performance testing scenarios and validation
# 6. UI performance improvements if frontend components exist

/sc:improve . --type performance --measure-impact --all-mcp --validate
# Expected: Coordinated optimization across all system layers with impact measurement

Enterprise-Scale Security Audit:

# Comprehensive security analysis with all available intelligence
/sc:analyze enterprise-app/ --focus security --ultrathink --all-mcp --enterprise-compliance

# Multi-layer security analysis:
# - Sequential: Systematic threat modeling and security analysis
# - Context7: Official security patterns and compliance requirements
# - Serena: Historical security decisions and architectural context
# - Playwright: Security testing scenarios and vulnerability validation
# - Quality gates: Compliance validation and security standards verification

# Expected deliverables:
# 1. Comprehensive threat model with attack vector analysis
# 2. Compliance assessment against industry standards (SOC 2, GDPR, HIPAA)
# 3. Vulnerability assessment with priority ranking
# 4. Automated security testing scenarios
# 5. Security improvement roadmap with implementation priorities
# 6. Executive summary with risk assessment and business impact

Advanced Orchestration Patterns

Parallel Development Coordination:

# Complex project requiring parallel development streams
/sc:spawn "enterprise platform development" --parallel --concurrency 5 --orchestrate

# Intelligent parallel coordination:
# Stream 1: Frontend development (frontend-architect + Magic MCP)
# Stream 2: Backend API development (backend-architect + Context7)
# Stream 3: Database design and optimization (database specialist + performance-engineer)
# Stream 4: DevOps and infrastructure (devops-architect + monitoring setup)
# Stream 5: Security implementation (security-engineer + compliance validation)

# Orchestration intelligence:
# - Dependency awareness: Backend API completion before frontend integration
# - Resource optimization: Parallel execution where possible, sequential where required
# - Quality gates: Continuous validation across all development streams
# - Progress synchronization: Coordinated milestones and integration points
# - Risk management: Early identification of blockers and dependency conflicts

Adaptive Learning and Optimization:

# Advanced session management with learning and adaptation
/sc:load "long-term-project" --adaptive-learning --pattern-recognition

# Advanced session capabilities:
# - Pattern recognition across development sessions
# - Adaptive strategy improvement based on project history
# - Intelligent tool selection based on project characteristics
# - Quality prediction and proactive issue prevention
# - Performance optimization based on historical bottlenecks

/sc:reflect "development patterns and optimization opportunities" --learning-analysis

# Expected analysis:
# 1. Development pattern analysis and efficiency opportunities
# 2. Tool usage optimization recommendations
# 3. Quality improvement strategies based on project history
# 4. Performance optimization priorities based on usage patterns
# 5. Process improvement recommendations for future development

Expert Optimization Strategies

Context-Aware Resource Management:

# Advanced resource optimization with intelligent adaptation
/sc:implement "high-complexity feature" --adaptive-resources --smart-optimization

# Adaptive behavior:
# - Dynamic tool selection based on real-time complexity assessment
# - Resource allocation optimization based on system constraints
# - Quality requirement adaptation based on feature criticality
# - Performance target adjustment based on usage patterns
# - Risk tolerance calibration based on project phase and requirements

Predictive Quality Management:

# Advanced quality management with predictive capabilities
/sc:analyze . --quality-prediction --risk-assessment --preventive-optimization

# Predictive capabilities:
# - Quality degradation prediction based on code changes
# - Performance regression risk assessment
# - Security vulnerability prediction based on code patterns
# - Maintenance burden forecasting
# - Technical debt accumulation modeling

# Expected outputs:
# 1. Quality trend analysis with degradation predictions
# 2. Proactive optimization recommendations
# 3. Risk mitigation strategies for predicted issues
# 4. Long-term maintainability roadmap
# 5. Investment priorities for technical debt management

Copy-Paste Examples

Immediate Use Commands

Quick Project Setup:

# New React project with best practices
/sc:implement "React TypeScript project with routing, state management, and testing setup"

# New Node.js API with authentication
/sc:implement "Express.js REST API with JWT authentication and PostgreSQL integration"

# Python FastAPI with async support
/sc:implement "FastAPI application with async PostgreSQL and authentication middleware"

# Next.js full-stack application
/sc:implement "Next.js 14 application with App Router, TypeScript, and Tailwind CSS"

Common Development Tasks:

# Code quality improvement
/sc:analyze . --focus quality && /sc:improve --safe-mode && /sc:test --coverage

# Security audit and fixes
/sc:analyze . --focus security --depth deep && /sc:improve --type security

# Performance optimization workflow
/sc:analyze . --focus performance && /sc:improve --type performance --measure-impact

# Documentation generation
/sc:document . --type comprehensive --include-examples --audience developers

Quick Troubleshooting:

# API performance issues
/sc:troubleshoot "API response time slow" && /sc:analyze api/ --focus performance

# Build failures
/sc:troubleshoot "build failing with dependency errors" && /sc:cleanup --dependencies

# Database connection issues
/sc:troubleshoot "database connection timeout" && /sc:analyze db/ --focus configuration

# Frontend rendering problems
/sc:troubleshoot "React components not rendering correctly" && /sc:analyze src/components/ --focus debugging

Ready-to-Execute Workflows

Full-Stack Development (Copy & Paste):

# Complete e-commerce development workflow
/sc:brainstorm "e-commerce platform for small business" && /sc:save "ecommerce-requirements"
/sc:load "ecommerce-requirements" && /sc:design "e-commerce architecture" --type system
/sc:implement "user authentication with social login" && /sc:test --type integration
/sc:implement "product catalog with search and filtering" && /sc:test --type unit
/sc:implement "shopping cart and checkout with Stripe" && /sc:test --type e2e
/sc:implement "admin dashboard with analytics" && /sc:test --comprehensive
/sc:implement "production deployment with monitoring" && /sc:save "ecommerce-complete"

API Development (Copy & Paste):

# Complete REST API development
/sc:design "blog management API" --type api --format openapi
/sc:implement "Express.js blog API with CRUD operations" && /sc:test --type unit
/sc:implement "JWT authentication middleware" && /sc:test --type security
/sc:implement "PostgreSQL integration with migrations" && /sc:test --type integration
/sc:document api/ --type api --format swagger && /sc:test --type e2e
/sc:implement "rate limiting and security middleware" && /sc:analyze . --focus security

Mobile App Development (Copy & Paste):

# React Native app development workflow
/sc:brainstorm "fitness tracking mobile app" && /sc:design "mobile app architecture"
/sc:implement "React Native app with navigation and state management"
/sc:implement "user authentication and profile management"
/sc:implement "fitness tracking features with device integration"
/sc:implement "social features and progress sharing"
/sc:test --type mobile --comprehensive && /sc:improve --focus performance

Common Problem Solutions (Copy & Paste)

Performance Issues:

# Web application performance optimization
/sc:analyze . --focus performance --comprehensive
/sc:improve frontend/ --type performance --bundle-optimization
/sc:improve backend/ --type performance --database-optimization
/sc:test --type performance --load-testing
/sc:implement "caching strategy with Redis" && /sc:test --performance-impact

Security Hardening:

# Complete security hardening workflow
/sc:analyze . --focus security --depth deep --compliance
/sc:implement "security headers and CORS configuration"
/sc:implement "input validation and sanitization middleware"
/sc:implement "rate limiting and DDoS protection"
/sc:test --type security --penetration-testing
/sc:document security/ --type security-guide --compliance-ready

Code Quality Improvement:

# Code quality enhancement workflow
/sc:analyze . --focus quality --comprehensive
/sc:cleanup --dead-code --organize-imports --format-code
/sc:improve . --type maintainability --refactor-patterns
/sc:test --type unit --coverage-target-90
/sc:document . --type inline --docstring-coverage

Development Environment Setup (Copy & Paste)

Frontend Development Environment:

# Complete frontend setup with best practices
/sc:implement "Vite React TypeScript project with ESLint, Prettier, and Tailwind"
/sc:implement "component library setup with Storybook"
/sc:implement "testing setup with Vitest and React Testing Library"
/sc:implement "CI/CD pipeline for frontend deployment"
/sc:document frontend/ --type developer-guide --setup-instructions

Backend Development Environment:

# Complete backend setup with monitoring
/sc:implement "Node.js TypeScript project with Express and Prisma"
/sc:implement "Docker containerization with multi-stage builds"
/sc:implement "PostgreSQL setup with migrations and seeding"
/sc:implement "monitoring setup with Prometheus and Grafana"
/sc:implement "logging and error tracking with Winston and Sentry"

DevOps Pipeline Setup:

# Complete CI/CD pipeline setup
/sc:implement "GitHub Actions workflow with testing and deployment"
/sc:implement "Docker multi-stage builds for production optimization"
/sc:implement "Kubernetes deployment with ingress and monitoring"
/sc:implement "Infrastructure as Code with Terraform"
/sc:implement "monitoring and alerting with DataDog/New Relic"

Related Guides

Learning Progression Roadmap

🌱 Beginner Level (Week 1-2)

Essential Foundation:

• Quick Start Guide - 5-minute setup and first commands
• Installation Guide - Complete installation and configuration
• Commands Reference - Master core commands (/sc:brainstorm, /sc:analyze, /sc:implement)

First Steps Practice:

• Try Quick Examples from this cookbook
• Practice Getting Started Examples
• Complete simple Project Workflow Examples

Success Criteria:

• Can install and configure SuperClaude successfully
• Comfortable with 5-10 core commands
• Can complete simple workflows independently

---

🌿 Intermediate Level (Week 3-6)

Enhanced Capabilities:

• Behavioral Modes - Context optimization and mode coordination
• Agents Guide - Specialist coordination and multi-agent workflows
• Flags Guide - Advanced flag combinations and optimization

Practical Application:

• Work through Command Examples by Category
• Practice Agent Examples and Mode Examples
• Complete intermediate Real-World Scenarios

Success Criteria:

• Understands agent coordination and mode selection
• Can optimize workflows with appropriate flags
• Comfortable with complex multi-step projects

---

🌲 Advanced Level (Month 2+)

Expert Coordination:

• MCP Servers - Enhanced capabilities and server coordination
• Session Management - Long-term project workflows
• Best Practices - Optimization strategies and expert techniques

Mastery Development:

• Practice Advanced Examples and expert coordination
• Complete enterprise-scale Real-World Scenarios
• Develop custom workflows and optimization strategies

Success Criteria:

• Can coordinate complex multi-tool workflows
• Masters session management for long-term projects
• Develops optimization strategies for specific domains

---

🔧 Expert Level (Month 3+)

Framework Development:

• Technical Architecture - Deep system understanding
• Contributing Code - Framework development and contribution
• Testing & Debugging - Advanced testing and optimization

Community Leadership:

• Contribute to framework development and documentation
• Help community members with complex scenarios
• Develop new patterns and share advanced techniques

Success Criteria:

• Contributes to SuperClaude framework development
• Mentors other users and solves complex problems
• Innovates new usage patterns and optimizations

Quick Reference by Use Case

Web Development:

• Frontend: Magic MCP Examples + React Workflows
• Backend: API Development Examples + Security Focus
• Full-Stack: E-commerce Scenario + Multi-Agent Coordination

Mobile Development:

• React Native: Mobile App Workflow + Performance Optimization
• iOS/Android: Platform-Specific Examples

DevOps & Infrastructure:

• CI/CD: Pipeline Examples + DevOps Workflows
• Monitoring: Infrastructure Examples
• Security: Security Hardening + Compliance Examples

Data & Analytics:

• Data Processing: Python Examples + Performance Focus
• Machine Learning: Advanced Coordination

Support Resources

Community Support:

• GitHub Discussions - Ask questions and share experiences
• GitHub Issues - Report bugs and request features

Advanced Learning:

• Troubleshooting Guide - Common issues and solutions
• Best Practices - Optimization and expert techniques

Development Resources:

• Contributing Guidelines - Join framework development
• Technical Documentation - Deep architectural understanding

---

Your Learning Journey:

Start with the Quick Examples, progress through real-world scenarios, and eventually master advanced coordination patterns. SuperClaude grows with you - from simple commands to sophisticated development orchestration.

Remember: Every expert was once a beginner. Focus on practical application, experiment with different approaches, and don't hesitate to ask the community for help when needed.