SuperClaude/Guides/best-practices.md

SuperClaude Best Practices Guide

A comprehensive guide to maximizing your effectiveness with SuperClaude through proven patterns and optimization strategies

Table of Contents

1. Getting Started Right
2. Command Mastery
3. Flag Optimization
4. Agent Coordination
5. MCP Server Strategy
6. Workflow Patterns
7. Performance Optimization
8. Quality & Safety
9. Advanced Patterns
10. Learning & Growth

---

Getting Started Right

The SuperClaude Mindset

Core Principle: SuperClaude is designed to handle complexity for you. Focus on expressing your intent clearly, and let the system optimize execution. For working examples of these principles, see Examples Cookbook.

✅ DO: Trust the intelligent routing system

• Just type /analyze auth.js - SuperClaude picks appropriate tools
• Use basic commands first, learn advanced features gradually
• Let behavioral modes activate automatically

❌ DON'T: Try to micromanage every detail

• Don't memorize all flags and agents upfront
• Don't specify tools unless you need to override defaults
• Don't overcomplicate simple tasks

Essential First Session Pattern

# The proven startup sequence
/sc:load                    # Initialize session with project context
/sc:analyze .               # Understand project structure and patterns
/sc:brainstorm "goals"      # Interactive discovery for unclear requirements
/sc:implement feature       # Development with auto-optimization
/sc:save                    # Persist session insights

Why this works: Establishes persistent context, gathers intelligence, enables cross-session learning.

Foundation Practices

Session Initialization

# Always start sessions properly
/sc:load --deep             # Deep project understanding
/sc:load --summary          # Quick context for familiar projects

Evidence-Based Development

# Validate before building
/sc:analyze existing-code   # Understand patterns first
/sc:test --coverage         # Verify current state
/sc:implement feature       # Build on solid foundation
/sc:test feature           # Validate implementation

Progressive Enhancement

# Start simple, add complexity intelligently
/sc:build                  # Basic implementation
/sc:improve --performance  # Targeted optimization
/sc:test --comprehensive   # Full validation

---

Command Mastery

Essential Command Patterns

Analysis Commands - Understanding before action

/sc:analyze path --focus domain        # Targeted analysis
/sc:explain complex-code.js            # Educational breakdown
/sc:troubleshoot "specific issue"      # Problem investigation

Development Commands - Building with intelligence

/sc:implement feature-name             # Smart feature creation
/sc:build --optimize                   # Optimized builds
/sc:design component --type ui         # Architecture/UI design

Quality Commands - Maintaining excellence

/sc:improve legacy-code/               # Systematic improvement
/sc:cleanup technical-debt/            # Targeted cleanup
/sc:test --with-coverage               # Quality validation

Command Combination Strategies

Analysis → Implementation Pattern

/sc:analyze auth/ --focus security     # Understand security landscape
/sc:implement user-auth --secure       # Build with security insights
/sc:test auth --security              # Validate security implementation

Brainstorm → Design → Implement Pattern

/sc:brainstorm "user dashboard"        # Requirements discovery
/sc:design dashboard --type component  # Architecture planning
/sc:implement dashboard                # Informed implementation

Load → Analyze → Improve Pattern

/sc:load --deep                       # Establish context
/sc:analyze . --focus quality         # Identify improvement areas
/sc:improve problematic-areas/        # Systematic enhancement

Command Selection Matrix

Task Type	Primary Command	Secondary Commands	Expected Outcome
New Feature	/sc:implement	/sc:design, /sc:test	Complete working feature
Code Issues	/sc:troubleshoot	/sc:analyze, /sc:improve	Root cause + solution
Quality Problems	/sc:improve	/sc:cleanup, /sc:test	Enhanced code quality
Architecture Review	/sc:analyze --focus architecture	/sc:reflect, /sc:document	System understanding
Unclear Requirements	/sc:brainstorm	/sc:estimate, /sc:task	Clear specifications

---

Flag Optimization

Flag Selection Strategy

Core Principle: Flags should enhance, not complicate. Most flags activate automatically - use manual flags only for overrides or specific needs.

High-Impact Flag Combinations

Deep Analysis Pattern

/sc:analyze codebase/ --think-hard --focus architecture --validate
# Triggers: Sequential MCP + Context7 + Architecture agent + validation gates
# Result: Comprehensive system analysis with safety checks

Performance Optimization Pattern

/sc:improve app/ --focus performance --loop --iterations 3
# Triggers: Performance engineer + iterative improvement cycles
# Result: Systematically optimized performance with measurement

Security Assessment Pattern

/sc:analyze auth/ --focus security --ultrathink --safe-mode
# Triggers: Security engineer + Sequential MCP + maximum validation
# Result: Comprehensive security analysis with conservative execution

Flag Efficiency Rules

Flag Priority Hierarchy

1. Safety flags (--safe-mode, --validate) - Always take precedence
2. Scope flags (--scope project) - Define boundaries first
3. Focus flags (--focus security) - Target expertise second
4. Optimization flags (--loop, --uc) - Enhance performance last

Automatic vs Manual Flags

• Let auto-activate: --brainstorm, --introspect, --orchestrate
• Manually specify: --focus, --scope, --think-hard
• Rarely needed: --concurrency, --iterations

Flag Combination Templates

For Complex Debugging

/sc:troubleshoot issue --think-hard --focus root-cause --validate

For Large Codebase Analysis

/sc:analyze . --delegate auto --scope project --uc

For Production Changes

/sc:implement feature --safe-mode --validate --with-tests

---

Agent Coordination

Understanding Agent Auto-Activation

How Agent Selection Works

1. Request Analysis: SuperClaude analyzes your request for domain keywords
2. Context Evaluation: Considers project type, files involved, previous session history
3. Agent Matching: Activates appropriate specialist based on expertise mapping
4. Multi-Agent Coordination: Enables multiple agents for cross-domain issues

Strategic Agent Usage

Single-Domain Tasks - Let auto-activation work

/sc:analyze auth.js                    # → Security Engineer
/sc:implement responsive-navbar        # → Frontend Architect  
/sc:troubleshoot performance-issue     # → Performance Engineer

Multi-Domain Tasks - Strategic combinations

/sc:implement payment-system           # → Backend + Security + Quality Engineers
/sc:analyze system-architecture        # → System + Performance + Security Architects
/sc:improve legacy-application         # → Quality + Refactoring + System experts

Agent Coordination Patterns

Security-First Development

/sc:analyze codebase --focus security  # Security Engineer analyzes
/sc:implement auth --secure            # Security Engineer oversees implementation
/sc:test auth --security              # Security + Quality Engineers validate

Performance-Driven Optimization

/sc:analyze performance-bottlenecks    # Performance Engineer identifies issues
/sc:improve slow-components            # Performance + Quality Engineers optimize
/sc:test performance --benchmarks      # Performance Engineer validates improvements

Architecture Evolution

/sc:analyze current-architecture       # System Architect reviews existing design
/sc:design new-architecture           # System + Domain Architects collaborate  
/sc:implement migration-plan          # Multiple specialists coordinate transition

Agent Specialization Matrix

Domain	Primary Agent	Supporting Agents	Best Commands
Security	Security Engineer	Quality Engineer, Root Cause Analyst	/sc:analyze --focus security
Performance	Performance Engineer	System Architect, Quality Engineer	/sc:improve --focus performance
Frontend	Frontend Architect	Quality Engineer, Learning Guide	/sc:design --type component
Backend	Backend Architect	Security Engineer, Performance Engineer	/sc:implement --type api
Architecture	System Architect	Performance Engineer, Security Engineer	/sc:analyze --focus architecture
Quality	Quality Engineer	Refactoring Expert, Root Cause Analyst	/sc:improve --with-tests

---

MCP Server Strategy

MCP Server Selection Matrix

Choose MCP servers based on task complexity and domain requirements

Task Type	Recommended MCP	Alternative	Trigger Conditions
UI Components	Magic	Manual coding	UI keywords, React/Vue mentions
Complex Analysis	Sequential	Native reasoning	>3 components, architectural questions
Documentation Lookup	Context7	Web search	Import statements, framework questions
Code Editing	Morphllm	Individual edits	>3 files, pattern-based changes
Symbol Operations	Serena	Manual search	Refactoring, large codebase navigation
Browser Testing	Playwright	Unit tests	E2E scenarios, visual validation

High-Performance MCP Combinations

Frontend Development Stack

# Magic + Context7 + Sequential
/sc:implement dashboard component --magic --c7 --seq
# Magic generates UI → Context7 provides framework patterns → Sequential coordinates

Backend Analysis Stack

# Sequential + Context7 + Serena
/sc:analyze api-architecture --seq --c7 --serena
# Sequential structures analysis → Context7 provides docs → Serena maps dependencies

Quality Improvement Stack

# Morphllm + Serena + Sequential  
/sc:improve legacy-codebase --morph --serena --seq
# Sequential plans improvements → Serena maps symbols → Morphllm applies changes

MCP Optimization Strategies

Token Efficiency with MCP

• Use --uc flag with complex MCP operations
• Sequential + Morphllm combination provides compressed analysis
• Magic components reduce UI implementation tokens significantly

Parallel MCP Processing

# Enable concurrent MCP server usage
/sc:analyze frontend/ --magic --c7 --concurrency 5

MCP Server Resource Management

# Conservative MCP usage for production
/sc:implement feature --safe-mode --validate
# Auto-enables appropriate MCP servers with safety constraints

When NOT to Use MCP Servers

Simple tasks that don't benefit from external tools:

• Basic explanations: "explain this function"
• Single file edits: "fix this typo"
• General questions: "what is React?"
• Quick analysis: "is this code correct?"

Use --no-mcp flag when:

• Performance is critical and you need fastest response
• Working in air-gapped environments
• Simple tasks where MCP overhead isn't justified
• Debugging MCP-related issues

---

Workflow Patterns

The Universal SuperClaude Workflow

Phase 1: Context Establishment

/sc:load --deep                       # Initialize project understanding
/sc:analyze . --scope project         # Map current state

Phase 2: Requirement Clarification

/sc:brainstorm "unclear requirements" # Interactive discovery
/sc:estimate task-scope              # Resource planning

Phase 3: Implementation

/sc:implement features               # Development with auto-optimization
/sc:test implementation             # Quality validation

Phase 4: Iteration & Persistence

/sc:improve --loop                  # Continuous enhancement
/sc:save --checkpoint              # Preserve insights

Domain-Specific Workflows

New Project Setup

/sc:load --deep                     # Understand project structure
/sc:analyze . --focus architecture  # Map existing patterns
/sc:brainstorm "development goals"   # Clarify objectives
/sc:task "setup development env"     # Plan setup tasks
/sc:build --optimize                # Establish build pipeline
/sc:document --type guide "setup"   # Create setup documentation
/sc:save                           # Preserve project insights

Feature Development

/sc:load                           # Load project context
/sc:brainstorm "feature idea"       # Requirements discovery  
/sc:design feature --type component # Architecture planning
/sc:implement feature              # Development with validation
/sc:test feature --comprehensive   # Quality assurance
/sc:improve feature --performance  # Optimization
/sc:document feature               # Documentation
/sc:save --checkpoint              # Save session state

Bug Investigation & Resolution

/sc:load --summary                 # Quick context loading
/sc:troubleshoot "bug description" # Root cause analysis
/sc:analyze affected-areas         # Impact assessment
/sc:implement fix --validate       # Safe fix implementation
/sc:test fix --comprehensive       # Comprehensive validation
/sc:reflect --type completion      # Verify resolution
/sc:save                          # Persist insights

Code Quality Improvement

/sc:load                          # Establish context
/sc:analyze . --focus quality     # Identify quality issues
/sc:improve problem-areas/        # Systematic improvements
/sc:cleanup technical-debt/       # Debt reduction
/sc:test --coverage               # Validation with coverage
/sc:reflect --type quality        # Quality assessment
/sc:save                         # Preserve improvements

Workflow Optimization Principles

Parallelization Opportunities

# Parallel analysis
/sc:analyze frontend/ &            # Background frontend analysis
/sc:analyze backend/ &             # Background backend analysis  
/sc:analyze tests/ &               # Background test analysis
wait && /sc:reflect --type summary # Consolidate findings

Checkpoint Strategy

• Every 30 minutes: /sc:save --checkpoint
• Before risky operations: /sc:save --backup
• After major completions: /sc:save --milestone
• End of sessions: /sc:save --final

Context Preservation

# Start of each session
/sc:load --recent                 # Load recent context
/sc:reflect --type session-start  # Understand current state

# End of each session
/sc:reflect --type completion     # Assess achievements
/sc:save --insights              # Preserve learnings

---

Performance Optimization

Token Efficiency Strategies

Automatic Token Optimization SuperClaude automatically enables token efficiency when:

• Context usage >75%
• Large-scale operations (>50 files)
• Complex multi-step workflows

Manual Token Optimization

/sc:analyze large-codebase --uc             # Ultra-compressed analysis
/sc:implement complex-feature --token-efficient # Compressed implementation

Symbol Communication Patterns When token efficiency mode activates, expect:

• ✅ ❌ ⚠️ for status indicators
• → ⇒ ⇄ for logic flow
• 🔍 🔧 ⚡ 🛡️ for domain indicators
• Abbreviated technical terms: cfg, impl, perf, arch

Execution Speed Optimization

Parallel Processing Templates

# Multiple file analysis
/sc:analyze src/ tests/ docs/ --concurrency 8

# Batch operations  
/sc:improve file1.js file2.js file3.js --batch

# Delegated processing for large projects
/sc:analyze . --delegate auto --scope project

Resource-Aware Processing

# Conservative resource usage
/sc:build --safe-mode              # Auto-limits resource usage

# Controlled concurrency
/sc:test --concurrency 3           # Explicit concurrency limits

# Priority-based processing
/sc:improve critical/ --priority high

Memory and Context Optimization

Session Context Management

# Lightweight context for familiar projects
/sc:load --summary                 

# Deep context for complex projects
/sc:load --deep                    

# Context compression for large projects
/sc:load --uc                     

Progressive Context Building

# Start minimal, build context progressively
/sc:load --minimal                # Basic project loading
/sc:analyze core-areas            # Focus on essential components
/sc:load --expand critical-paths  # Expand context as needed

Performance Measurement

Built-in Performance Tracking

# Commands automatically track performance metrics:
/sc:analyze . --performance-metrics
/sc:build --timing
/sc:test --benchmark

Performance Validation Patterns

# Before optimization
/sc:analyze performance-bottlenecks --baseline

# After optimization  
/sc:test performance --compare-baseline

# Continuous monitoring
/sc:reflect --type performance --trend

---

Quality & Safety

Safety-First Development

Core Safety Principles

1. Validate before execution - Always run analysis before changes
2. Incremental changes - Small, verifiable steps over large changes
3. Rollback capability - Maintain ability to undo changes
4. Evidence-based decisions - All claims must be verifiable

Critical Safety Patterns

# Always check git status first
git status && git branch

# Read before any file operations  
/sc:analyze file.js              # Understand before changing

# Use safe mode for production changes
/sc:implement feature --safe-mode

# Create checkpoints before risky operations
/sc:save --backup && /sc:implement risky-change

Quality Assurance Patterns

Quality Gates Framework

# Analysis quality gate
/sc:analyze code --validate        # Validates analysis accuracy

# Implementation quality gate  
/sc:implement feature --with-tests # Includes quality validation

# Deployment quality gate
/sc:build --quality-check         # Pre-deployment validation

Comprehensive Testing Strategy

# Unit testing
/sc:test components/ --unit

# Integration testing
/sc:test api/ --integration  

# E2E testing (triggers Playwright MCP)
/sc:test user-flows/ --e2e

# Security testing
/sc:test auth/ --security

# Performance testing  
/sc:test critical-paths/ --performance

Error Prevention & Recovery

Proactive Error Prevention

# Validate before risky operations
/sc:analyze risky-area --focus safety --validate

# Use conservative execution for critical systems
/sc:implement critical-feature --safe-mode --validate

# Enable comprehensive testing
/sc:test critical-feature --comprehensive --security

Error Recovery Patterns

# Systematic debugging approach
/sc:troubleshoot error --think-hard --root-cause

# Multi-perspective analysis
/sc:analyze error-context --focus debugging --ultrathink

# Validated fix implementation
/sc:implement fix --validate --with-tests --safe-mode

Code Quality Standards

Quality Enforcement Rules

• No partial features - Complete everything you start
• No TODO comments - Finish implementations, don't leave placeholders
• No mock implementations - Build real, working code
• Evidence-based claims - All technical statements must be verifiable

Quality Validation Commands

# Code quality assessment
/sc:analyze . --focus quality --comprehensive

# Technical debt identification
/sc:analyze . --focus debt --report

# Quality improvement planning
/sc:improve low-quality-areas/ --plan

# Quality trend analysis
/sc:reflect --type quality --trend

---

Advanced Patterns

Multi-Layer Orchestration

Complex Project Coordination

# Enable advanced orchestration for large projects
/sc:task "modernize legacy system" --orchestrate --delegate auto

# Multi-agent coordination for cross-domain problems
/sc:implement payment-system --all-mcp --think-hard --safe-mode

# Systematic refactoring with multiple specialists
/sc:improve legacy-codebase/ --delegate folders --loop --iterations 5

Resource-Constrained Optimization

# Maximum efficiency for large operations
/sc:analyze enterprise-codebase --uc --delegate auto --concurrency 15

# Token-optimized multi-step workflows
/sc:task complex-migration --token-efficient --orchestrate

# Performance-optimized batch processing  
/sc:improve multiple-modules/ --batch --performance-mode

Session Lifecycle Mastery

Advanced Session Management

# Intelligent session initialization
/sc:load --adaptive               # Adapts loading strategy to project complexity

# Cross-session learning
/sc:reflect --type learning       # Extract insights for future sessions

# Session comparison and evolution
/sc:reflect --type evolution --compare-previous

# Advanced checkpointing
/sc:save --milestone "major feature complete" --analytics

Session Intelligence Patterns

# Context-aware session resumption
/sc:load --context-aware          # Resumes with intelligent context

# Predictive session planning
/sc:task session-goals --predict-resources --estimate-time

# Session optimization recommendations
/sc:reflect --type optimization --recommendations

Expert-Level Command Combinations

Architecture Evolution Workflow

/sc:load --deep
/sc:analyze current-architecture --ultrathink --focus architecture  
/sc:design target-architecture --think-hard --validate
/sc:task migration-plan --orchestrate --delegate auto
/sc:implement migration --safe-mode --validate --loop
/sc:test migration --comprehensive --performance
/sc:reflect --type architecture --evolution
/sc:save --milestone "architecture evolved"

Security Hardening Workflow

/sc:load --security-focused
/sc:analyze . --focus security --ultrathink --all-mcp
/sc:troubleshoot security-vulnerabilities --think-hard --root-cause
/sc:implement security-fixes --safe-mode --validate --with-tests
/sc:test security/ --security --comprehensive --e2e  
/sc:reflect --type security --assessment
/sc:save --security-audit-complete

Performance Optimization Workflow

/sc:load --performance-focused
/sc:analyze performance-bottlenecks --focus performance --think-hard
/sc:implement optimizations --validate --loop --iterations 3
/sc:test performance --benchmark --compare-baseline
/sc:reflect --type performance --improvement-metrics  
/sc:save --performance-optimized

Custom Workflow Development

Creating Repeatable Patterns

# Define custom workflow templates
/sc:task "define code-review workflow" --template

# Parameterized workflow execution  
/sc:execute code-review-workflow --target auth/ --depth comprehensive

# Workflow optimization and refinement
/sc:improve workflow-template --based-on results

---

Learning & Growth

Progressive Learning Strategy

Phase 1: Foundation (Weeks 1-2)

• Master basic commands: /sc:load, /sc:analyze, /sc:implement, /sc:save
• Trust auto-activation - don't manually manage flags and agents
• Establish consistent session patterns
• Focus on quality workflows over advanced features

Phase 2: Specialization (Weeks 3-6)

• Experiment with domain-specific commands for your primary work
• Learn flag combinations that enhance your specific workflows
• Understand when different agents activate and why
• Develop personal workflow templates

Phase 3: Optimization (Weeks 7-12)

• Master advanced flag combinations for complex scenarios
• Leverage MCP servers for specialized tasks
• Develop multi-session workflows with persistent context
• Create custom orchestration patterns

Phase 4: Expertise (Months 4+)

• Design sophisticated multi-agent coordination workflows
• Optimize for token efficiency and performance at scale
• Mentor others using proven patterns you've developed
• Contribute workflow innovations back to the community

Learning Acceleration Techniques

Experimentation Framework

# Try unfamiliar commands in safe environments
/sc:analyze sample-project --think-hard   # Observe how deep analysis works
/sc:brainstorm "imaginary project"        # See requirements discovery in action
/sc:reflect --type learning              # Review what you learned

Pattern Recognition Development

• Notice auto-activations: Pay attention to which agents and flags activate automatically
• Compare approaches: Try the same task with different commands/flags
• Measure outcomes: Use reflection commands to assess effectiveness
• Document discoveries: Save insights about what works best for your projects

Knowledge Reinforcement Patterns

# Weekly learning review
/sc:reflect --type learning --timeframe week

# Monthly skill assessment  
/sc:reflect --type skills --improvement-areas

# Quarterly workflow optimization
/sc:reflect --type workflows --optimization-opportunities

Building Expertise

Advanced Skill Development Areas

1. Agent Coordination Mastery

• Learn to predict which agents will activate for different requests
• Understand cross-domain collaboration patterns
• Develop skills in manual agent coordination for edge cases

2. MCP Server Optimization

• Master the decision matrix for when to use each MCP server
• Learn optimal MCP combinations for complex workflows
• Understand performance implications of different MCP strategies

3. Performance Engineering

• Develop intuition for token efficiency opportunities
• Master parallel processing and resource optimization
• Learn to balance quality vs. speed based on context

4. Quality Assurance Excellence

• Internalize quality gate patterns for different project types
• Develop systematic testing strategies using SuperClaude
• Master error prevention and recovery patterns

Continuous Improvement Framework

Self-Assessment Questions

• Which SuperClaude patterns save you the most time?
• What types of problems do you still solve manually that could be automated?
• How has your code quality improved since using SuperClaude systematically?
• Which advanced features haven't you explored yet that might benefit your work?

Measurement Strategies

# Track productivity improvements
/sc:reflect --type productivity --baseline vs-current

# Assess code quality trends
/sc:reflect --type quality --trend-analysis

# Measure learning velocity
/sc:reflect --type learning --skill-development

Community Engagement

• Share effective workflow patterns you discover
• Learn from others' optimization strategies
• Contribute to SuperClaude documentation improvements
• Mentor newcomers using proven teaching patterns

---

Quick Reference

Essential Commands Cheat Sheet

# Session Management
/sc:load                    # Initialize session context
/sc:save                    # Persist session insights  
/sc:reflect                 # Review session outcomes

# Core Development
/sc:analyze path            # Intelligent analysis
/sc:implement feature       # Smart implementation
/sc:improve code           # Systematic enhancement
/sc:test target            # Comprehensive testing

# Problem Solving
/sc:brainstorm topic       # Requirements discovery
/sc:troubleshoot issue     # Root cause analysis
/sc:explain concept        # Educational breakdown

High-Impact Flag Combinations

--think-hard --focus domain --validate     # Deep domain analysis with safety
--safe-mode --with-tests --quality-check   # Production-ready implementation  
--uc --orchestrate --delegate auto         # Large-scale efficient processing
--loop --iterations 3 --performance        # Iterative optimization cycles

Emergency Troubleshooting

# When things go wrong
/sc:troubleshoot issue --ultrathink --safe-mode --root-cause

# When performance is critical  
/sc:analyze problem --uc --no-mcp --focus performance

# When you need maximum safety
/sc:implement fix --safe-mode --validate --with-tests --quality-check

---

Conclusion

SuperClaude's power lies in its intelligent automation of complex development workflows. The key to mastery is:

1. Trust the automation - Let SuperClaude handle complexity while you focus on intent
2. Start simple - Master basic patterns before exploring advanced features
3. Learn progressively - Add sophistication as your understanding deepens
4. Measure outcomes - Use reflection to validate that your patterns actually improve results
5. Stay curious - Experiment with new approaches and contribute discoveries back to the community

Remember: These best practices emerge from real usage. The most valuable patterns are often discovered through experimentation and adapted to your specific context. Use this guide as a foundation, but don't hesitate to develop your own optimized workflows based on your unique needs and discoveries.

Start with the essentials, trust the intelligence, and let your expertise emerge through practice.

Related Guides

🚀 Foundation (Essential Before Best Practices)

• Installation Guide - Get SuperClaude set up properly
• SuperClaude User Guide - Understanding the framework philosophy
• Examples Cookbook - Working examples to practice with

📚 Core Knowledge (Apply These Practices)

• Commands Guide - All 21 commands with optimization opportunities
• Session Management Guide - Session lifecycle mastery
• Agents Guide - Agent coordination best practices

⚙️ Advanced Optimization (Power User Techniques)

• Flags Guide - Advanced flag combinations and control
• Behavioral Modes Guide - Mode coordination patterns
• Technical Architecture Guide - System understanding for optimization

🔧 Quality and Safety (Prevention Strategies)

• Troubleshooting Guide - Prevention patterns and issue avoidance

📖 How to Use This Guide:

1. Start with Getting Started Right for foundational patterns
2. Apply Command Mastery to your daily workflow
3. Use Workflow Patterns for specific development scenarios
4. Graduate to Advanced Patterns for complex projects

🎯 Implementation Strategy:

• Week 1-2: Focus on Getting Started Right and basic Command Mastery
• Week 3-4: Implement Workflow Patterns for your common tasks
• Month 2: Explore Agent Coordination and MCP Server Strategy
• Month 3+: Master Advanced Patterns and Performance Optimization