PROJECT_INDEX.md         # Project quick start (3K tokens)

src/superclaude/commands/
├── pm.md              # /sc:pm - Project Manager Agent (593 lines, most detailed)
├── task.md            # /sc:task - Task Management
├── workflow.md        # /sc:workflow - Workflow Generator
├── spawn.md           # /sc:spawn - Meta-System Orchestration
├── brainstorm.md      # /sc:brainstorm - Requirements Discovery
├── implement.md       # /sc:implement - Feature Implementation
├── design.md          # /sc:design - System Design
├── research.md        # /sc:research - Web Research
├── analyze.md         # /sc:analyze - Code Analysis
├── troubleshoot.md    # /sc:troubleshoot - Issue Diagnosis
├── improve.md         # /sc:improve - Code Improvement
├── cleanup.md         # /sc:cleanup - Dead Code Removal
├── test.md            # /sc:test - Testing
├── build.md           # /sc:build - Building
├── explain.md         # /sc:explain - Code Explanation
├── document.md        # /sc:document - Documentation
├── git.md             # /sc:git - Git Operations
├── estimate.md        # /sc:estimate - Development Estimation
├── reflect.md         # /sc:reflect - Task Reflection
├── spec-panel.md      # /sc:spec-panel - Expert Spec Review (414 lines)
├── business-panel.md  # /sc:business-panel - Business Analysis
├── index-repo.md      # /sc:index-repo - Repository Indexing
├── index.md           # /sc:index - Project Documentation
├── load.md            # /sc:load - Session Load
├── save.md            # /sc:save - Session Save
├── select-tool.md     # /sc:select-tool - MCP Tool Selection
├── recommend.md       # /sc:recommend - Command Recommendation
├── help.md            # /sc:help - Help
├── sc.md              # /sc - Main dispatcher
└── agent.md           # /sc:agent - Custom agents

plugins/superclaude/commands/  # Copy for plugin distribution

src/superclaude/pm_agent/
├── confidence.py      # ConfidenceChecker (pre-execution)
├── self_check.py      # SelfCheckProtocol (post-implementation)
└── reflexion.py       # ReflexionPattern (error learning)

src/superclaude/execution/
├── parallel.py        # Wave → Checkpoint → Wave pattern
├── reflection.py      # Session reflection
└── self_correction.py # Error correction

src/superclaude/pytest_plugin.py  # Fixtures: confidence_checker, self_check_protocol, etc.

CLAUDE.md              # Project setup, commands overview
PLANNING.md            # Architecture, design decisions
KNOWLEDGE.md           # Best practices, troubleshooting
TASK.md                # Current tasks

src/superclaude/skills/confidence-check/SKILL.md  # Confidence check skill

User: "I want to add authentication"
PM Agent:
  1. Activates Brainstorming Mode (if request is vague)
  2. Delegates to requirements-analyst
  3. Delegates to system-architect
  4. Delegates to security-engineer
  5. Delegates to backend-architect
  6. Delegates to quality-engineer
  7. Documents in CLAUDE.md

/sc:spawn [complex-task] [--strategy sequential|parallel|adaptive] [--depth normal|deep]

# Monolith migration
/sc:spawn "migrate legacy monolith to microservices" --strategy adaptive --depth deep
# Creates: Database design → Backend API → Frontend → Testing

# Feature with dependencies
/sc:spawn "implement user authentication system"
# Breakdown: Database design → Backend API → Frontend UI → Testing

/sc:task [action] [target] [--strategy systematic|agile|enterprise] [--parallel] [--delegate]

# Enterprise-level feature
/sc:task create "enterprise authentication system" --strategy systematic --parallel
# Activates architect + security + backend + frontend

# Agile sprint
/sc:task execute "feature backlog" --strategy agile --delegate
# Iterative execution with delegation

/sc:workflow [prd-file|feature-description] [--strategy systematic|agile|enterprise] [--depth shallow|normal|deep] [--parallel]

# From PRD file
/sc:workflow docs/PRD/auth-feature.md --strategy systematic --depth deep
# Result: "1. DB schema → 2. API → 3. UI → 4. Tests"

# From description
/sc:workflow "user authentication system" --strategy agile --parallel

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

# New product
/sc:brainstorm "AI-powered project management tool" --strategy systematic --depth deep
# Claude: What problems should it solve? For what team? Integrations?
# Result: Clear requirements document

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

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

/sc:research "latest developments in quantum computing 2024" --depth deep
/sc:research "competitive analysis of AI coding assistants" --depth exhaustive

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

# React component
/sc:implement user profile component --type component --framework react --with-tests

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

# Full-stack feature
/sc:implement payment processing system --type feature --with-tests

/sc:design [target] [--type architecture|api|component|database] [--format diagram|spec|code]

/sc:design user-management-system --type architecture --format diagram
/sc:design payment-api --type api --format spec
/sc:design e-commerce-db --type database --format diagram

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

/sc:analyze src/auth --focus security --depth deep
/sc:analyze --focus performance --format report
/sc:analyze src/components --focus quality --depth quick

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

/sc:troubleshoot "Null pointer exception in user service" --type bug --trace --fix
/sc:troubleshoot "TypeScript compilation errors" --type build --fix
/sc:troubleshoot "API response times degraded" --type performance

/sc:improve [target] [--type quality|performance|maintainability|style] [--safe] [--interactive]

/sc:improve src/ --type quality --safe
/sc:improve api-endpoints --type performance --interactive
/sc:improve auth-service --type security --validate

/sc:cleanup [target] [--type code|imports|files|all] [--safe|--aggressive] [--interactive]

/sc:cleanup src/ --type code --safe
/sc:cleanup --type imports --preview
/sc:cleanup --type all --interactive

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

/sc:test
/sc:test src/components --type unit --coverage
/sc:test --type e2e  # Activates Playwright MCP
/sc:test --watch --fix

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

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

/sc:explain [target] [--level basic|intermediate|advanced] [--format text|examples|interactive] [--context domain]

/sc:explain authentication.js --level basic
/sc:explain react-hooks --level intermediate --context react
/sc:explain microservices-system --level advanced --format interactive

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

/sc:document src/auth/login.js --type inline
/sc:document src/api --type api --style detailed
/sc:document payment-module --type guide --style brief

/sc:index-repo [mode=update|quick]

/sc:index-repo                # Full indexing
/sc:index-repo mode=update    # Update existing
/sc:index-repo mode=quick     # Quick (without tests)

/sc:spec-panel [spec|@file] [--mode discussion|critique|socratic] [--experts "name1,name2"] [--focus requirements|architecture|testing|compliance] [--iterations N]

# API specification review
/sc:spec-panel @auth_api.spec.yml --mode critique --focus requirements,architecture

# Requirements workshop
/sc:spec-panel "user story content" --mode discussion --experts "wiegers,adzic,cockburn"

# Learning through questions
/sc:spec-panel @my_first_spec.yml --mode socratic --iterations 2

# Iterative improvement (3 rounds)
/sc:spec-panel @complex_system.spec.yml --iterations 3 --format detailed

KARL WIEGERS - Requirements Quality:
❌ CRITICAL: Requirement R-001 lacks acceptance criteria
📝 RECOMMENDATION: Replace "handle gracefully" with "open circuit after 5 failures"
🎯 PRIORITY: High
📊 QUALITY IMPACT: +40% testability

MARTIN FOWLER - Interface Design:
⚠️ MINOR: CircuitBreaker couples state with execution
📝 RECOMMENDATION: Separate CircuitBreakerState from Executor

/sc:business-panel [content|@file] [--experts "porter,christensen"] [--mode discussion|debate|socratic] [--focus domain] [--synthesis-only]

# Business plan analysis
/sc:business-panel @business_plan.md

# Competitive analysis
/sc:business-panel @market_analysis.md --experts "porter,christensen" --focus "competitive-analysis"

# Strategy debate (stress-test)
/sc:business-panel @strategy.md --mode debate

# Synthesis only (without detailed analysis)
/sc:business-panel @pitch_deck.md --synthesis-only

PORTER: "The competitive position relies on cost leadership..."
CHRISTENSEN: "But cost leadership is vulnerable to disruption from below..."
KIM/MAUBORGNE: "Consider creating new market space instead..."
TALEB: "The real question: does this benefit from uncertainty?"

/sc:git [operation] [args] [--smart-commit] [--interactive]

/sc:git status
/sc:git commit --smart-commit  # Generates conventional commit message
/sc:git merge feature-branch --interactive

/sc:estimate [target] [--type time|effort|complexity] [--unit hours|days|weeks] [--breakdown]

/sc:estimate "user authentication system" --type time --unit days --breakdown
# Database design: 2 days
# Backend API: 3 days
# Frontend UI: 2 days
# Testing: 1 day
# Total: 8 days (85% confidence)

/sc:estimate "migrate to microservices" --type complexity --breakdown

/sc:reflect [--type task|session|completion] [--analyze] [--validate]

/sc:reflect --type task --analyze      # Current approach validation
/sc:reflect --type session --validate  # Session analysis
/sc:reflect --type completion          # Readiness check

VAGUE IDEA?
    └─→ /sc:brainstorm (clarify requirements)
            │
            ▼
NEED RESEARCH?
    └─→ /sc:research (search the web)
            │
            ▼
PRD READY?
    └─→ /sc:workflow (generate plan)
            │
            ▼
COMPLEX DECOMPOSITION?
    └─→ /sc:spawn (Epic → Story → Task)
            │
            ▼
NEED DESIGN?
    └─→ /sc:design (architecture, API, schemas)
            │
            ▼
READY TO CODE?
    └─→ /sc:implement (write code)
            │
            ▼
NEED TESTS?
    └─→ /sc:test (run tests)
            │
            ▼
NEED BUILD?
    └─→ /sc:build (build project)
            │
            ▼
SOMETHING BROKEN?
    └─→ /sc:troubleshoot (find the cause)
            │
            ▼
WANT IT BETTER?
    └─→ /sc:improve or /sc:cleanup
            │
            ▼
NEED DOCUMENTATION?
    └─→ /sc:document
            │
            ▼
NEED REVIEW?
    └─→ /sc:analyze (code) or /sc:spec-panel (specs)

/sc:spawn "build e-commerce platform"

Result (structure only!):
Epic: E-commerce Platform
├── Story: User Authentication
│   ├── Task: Database schema for users
│   ├── Task: Auth API endpoints
│   └── Task: Login UI
├── Story: Product Catalog
│   ├── Task: Product model
│   └── Task: Search functionality
└── Story: Checkout
    ├── Task: Cart logic
    └── Task: Payment integration

/sc:task create "user authentication" --strategy systematic --parallel

Workflow:
1. Activates architect persona → designs
2. Activates security persona → reviews
3. Activates backend persona → writes code (calls implement internally)
4. Activates qa persona → tests

/sc:implement user login form --type component --framework react --with-tests

Result:
- src/components/LoginForm.tsx (created)
- src/components/LoginForm.test.tsx (created)

/sc:spawn "build auth system"        ← Breaks into tasks
    │
    ├── Creates Task: "Design auth architecture"
    │       └── Can execute via /sc:design
    │
    ├── Creates Task: "Implement auth API"
    │       └── Can execute via /sc:task or /sc:implement
    │
    └── Creates Task: "Build login UI"
            └── Can execute via /sc:implement

/sc:task execute "auth system" --parallel
    │
    ├── Delegates backend → calls /sc:implement auth API
    ├── Delegates frontend → calls /sc:implement login form
    └── Delegates security → calls /sc:analyze --focus security

/sc:task "add logout button"

task thinks:
  1. Activate architect? → overkill for a button
  2. Activate security? → logout is simple
  3. Activate frontend? → ok
  4. Activate qa? → for a button?

Result: spent tokens on coordination for a single button

/sc:implement logout button --type component --framework react

implement:
  1. Reads existing code
  2. Writes button
  3. Done

Task concerns 1 domain (only frontend OR only backend)?
  → /sc:implement

Task concerns 2+ domains (frontend + backend + security)?
  → /sc:task

Unsure about architecture?
  → /sc:task (or first /sc:design)

Critical code (auth, payments, data)?
  → /sc:task (extra checks don't hurt)

/sc:design payment-system --type architecture

Result:
┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   Client    │────▶│  API Gateway │────▶│  Payment    │
│   (React)   │     │  (Express)   │     │  Service    │
└─────────────┘     └─────────────┘     └─────────────┘
                                              │
                                              ▼
                                        ┌─────────────┐
                                        │   Stripe    │
                                        │   Webhook   │
                                        └─────────────┘

+ API contracts
+ Database schema
+ Security requirements

/sc:workflow payment-system --strategy systematic

Result:
Phase 1: Foundation (Week 1)
  ├── Task 1.1: Setup database schema
  ├── Task 1.2: Create Payment model
  └── Task 1.3: Configure Stripe SDK

Phase 2: Backend (Week 2)
  ├── Task 2.1: Implement payment endpoints ← depends on 1.1, 1.2
  ├── Task 2.2: Add webhook handler ← depends on 1.3
  └── Task 2.3: Write unit tests

Phase 3: Frontend (Week 2-3) ← can start parallel with 2.2
  ├── Task 3.1: Payment form component
  └── Task 3.2: Confirmation page

Phase 4: Integration (Week 3)
  └── Task 4.1: E2E tests ← depends on all above

1. /sc:brainstorm "payment system"     → Requirements (WHAT we want)
          │
          ▼
2. /sc:design payment-system           → Architecture (HOW it's structured)
          │
          ▼
3. /sc:workflow payment-system         → Plan (IN WHAT ORDER)
          │
          ▼
4. /sc:implement ... (following plan)  → Code

.serena/
├── project.yml              # Configuration (languages, encoding, LSP settings)
├── .gitignore               # Git ignore
└── memories/
    ├── project_overview.md      # About the project, tech stack
    ├── suggested_commands.md    # Development commands
    ├── style_conventions.md     # Code styles and conventions
    └── task_completion.md       # Task completion checklist

# Initial setup (once)
serena activate_project .         # Activate project
serena onboarding                 # Create memories
# and/or
/sc:index-repo                    # Create PROJECT_INDEX.md

# On structural changes
/sc:index-repo mode=update        # Update INDEX (if using)
serena edit_memory ...            # Update memories (if needed)

# Option A: Via Serena (recommended)
1. serena activate_project .         # Activate project
2. serena onboarding                 # Create memories (project_overview, commands, etc.)

# Option B: Via index-repo
1. /sc:index-repo                    # Create PROJECT_INDEX.md

# Can use both — they complement each other

1. /sc:brainstorm "feature idea"     # Requirements gathering
2. /sc:design feature --type api     # Architecture design
3. /sc:workflow feature              # Implementation plan
4. /sc:implement step1               # Step-by-step implementation
5. /sc:test --coverage               # Testing

1. /sc:troubleshoot "error" --trace  # Diagnosis (finds code via Serena)
2. /sc:implement fix                 # Fix
3. /sc:test                          # Verification

1. /sc:analyze code --type quality   # Problem analysis (uses Serena)
2. /sc:improve code --focus X        # Improvement
3. /sc:cleanup --scope module        # Cleanup
4. /sc:test                          # Verification

1. /sc:analyze PR --type quality     # Code quality
2. /sc:analyze PR --type security    # Security
3. /sc:test --type integration       # Integration tests

1. /sc:brainstorm "idea"                    # Clarify requirements through dialogue
2. /sc:research "market + competitors"      # Market research
3. /sc:business-panel @idea.md --mode discussion  # Expert analysis (Porter, Christensen...)
   # → Get strategic insights
4. /sc:business-panel @idea.md --mode debate      # Stress-test idea (optional)
5. /sc:design system --type architecture    # Technical architecture
6. /sc:spec-panel @design.md --mode critique      # Specification review (Fowler, Wiegers...)
   # → Get technical recommendations

1. /sc:spec-panel @spec.md --mode socratic        # Questions to understand gaps
   # → Experts ask: "Who is primary stakeholder?"
2. Answer questions, expand spec
3. /sc:spec-panel @spec.md --mode critique        # Critical review
   # → Get: ❌ CRITICAL, ⚠️ MAJOR, priorities
4. /sc:spec-panel @spec.md --iterations 2         # Iterative improvement

1. /sc:design system --type architecture    # Create architecture
2. /sc:spec-panel @architecture.md --focus architecture --experts "fowler,newman,nygard"
   # → Fowler: "This violates single responsibility"
   # → Newman: "How handle service evolution?"
   # → Nygard: "What happens when this fails?"
3. Fix based on recommendations
4. /sc:workflow system                      # Implementation plan
5. /sc:implement ...                        # Implementation

1. /sc:business-panel @pitch.md --mode discussion
   # → Porter: competitive advantage
   # → Christensen: disruption potential
   # → Godin: tribe and story
2. /sc:business-panel @pitch.md --mode debate     # Stress-test arguments
3. /sc:business-panel @pitch.md --synthesis-only  # Final synthesis

1. /sc:brainstorm "enterprise feature"      # Requirements
2. /sc:business-panel @requirements.md      # Business validation
3. /sc:design feature --type architecture   # Architecture
4. /sc:spec-panel @design.md --focus architecture,testing  # Technical validation
5. /sc:workflow feature --depth deep        # Detailed plan
6. /sc:spawn "feature" --strategy adaptive  # Decompose into tasks
7. /sc:task execute task1 --parallel        # Execution with coordination
8. /sc:analyze feature --focus security     # Security review
9. /sc:test --type all --coverage           # Full testing

# Activate project
serena activate_project /path/to/SuperClaude_Framework

# Check memories
serena list_memories

# Read needed memory
serena read_memory project_overview.md
serena read_memory suggested_commands.md