SuperClaude/Docs/Reference/quick-start-practices.md

SuperClaude Quick Start Practices

Essential SuperClaude Fundamentals: Core practices for immediate productivity gains. Master these foundations to build confidence and establish effective development workflows from day one.

Focus: Quick wins, essential commands, basic workflows, and session management fundamentals for new users.

Table of Contents

Foundation Essentials

• Getting Started Right - Essential onboarding and workflow patterns
• Command Fundamentals - Core command mastery and selection
• Basic Flag Usage - Essential flags for immediate productivity
• Session Management Basics - Context preservation fundamentals

Quick Wins

• Daily Workflow Patterns - Proven daily development routines
• First Week Learning Path - Structured skill development
• Common Quick Fixes - Immediate problem resolution

See Also

• Advanced Patterns - Multi-agent coordination and expert techniques
• Optimization Guide - Performance and efficiency strategies

Getting Started Right

Foundation Principles

Start Simple, Scale Intelligently:

# Week 1: Master these essential commands
/sc:brainstorm "vague project idea"      # Requirements discovery
/sc:analyze existing-code/               # Code understanding  
/sc:implement "specific feature"         # Feature development
/sc:test --coverage                      # Quality validation

# Week 2-3: Add coordination
/sc:workflow "complex feature"           # Planning workflows
/sc:improve . --focus quality            # Code improvement
/sc:document . --scope project           # Documentation

# Week 4+: Master optimization
/sc:analyze . --ultrathink --all-mcp     # Advanced analysis
/sc:spawn "enterprise project" --orchestrate  # Complex coordination

Progressive Learning Path

Phase 1: Command Fundamentals (Days 1-7)

# Daily practice routine
Day 1: /sc:brainstorm "daily coding challenge"
Day 2: /sc:analyze sample-project/ --focus quality
Day 3: /sc:implement "simple CRUD API"
Day 4: /sc:test --type unit --coverage
Day 5: /sc:improve previous-work/ --safe-mode
Day 6: /sc:document your-project/ --scope project
Day 7: /sc:workflow "week 2 learning plan"

# Success metrics: Comfort with basic commands, understanding of output

Phase 2: Intelligent Coordination (Days 8-21)

# Multi-agent workflow practice
/sc:implement "secure user authentication with testing and documentation"
# Should activate: security-engineer + backend-architect + quality-engineer + technical-writer

# Mode optimization practice
/sc:brainstorm "complex project requirements"  # Brainstorming mode
/sc:spawn "multi-service architecture"         # Task management mode
/sc:analyze performance-issues/ --introspect   # Introspection mode

# Success metrics: Multi-agent coordination understanding, mode awareness

Phase 3: Session and Persistence (Days 22-30)

# Long-term project simulation
/sc:load new-project/ --scope project
/sc:save "project-baseline"

# Daily development cycle
/sc:load "project-baseline"
/sc:implement "daily feature"
/sc:test --integration
/sc:save "day-$(date +%m%d)-complete"

# Success metrics: Session management, context preservation, project continuity

Effective Onboarding Patterns

First Session Optimization:

# Optimal first session workflow
/sc:load your-project/                    # Establish project context
/sc:analyze . --scope project             # Understand codebase
/sc:document . --scope project            # Generate project overview
/sc:save "onboarding-complete"           # Save initial understanding

# Expected outcomes:
# - Complete project understanding documented
# - Architecture and quality baseline established  
# - Session context ready for productive development
# - Foundation for all future work sessions

Daily Workflow Establishment:

# Proven daily startup routine
/sc:load "current-project"               # Restore context
/sc:reflect "yesterday's progress"       # Review previous work
/sc:workflow "today's objectives"        # Plan daily work
/sc:implement "priority feature"         # Execute development
/sc:test --validate                      # Ensure quality
/sc:save "end-of-day-$(date +%m%d)"    # Preserve progress

# Time investment: 2-3 minutes setup, saves 20+ minutes daily

Command Fundamentals

Strategic Command Selection

Command Categories by Purpose:

Discovery Commands (Project Understanding):

# Use when: Starting new projects, onboarding, architecture review
/sc:load project/ --scope project         # Project understanding
/sc:analyze . --focus architecture        # System design analysis
/sc:brainstorm "project enhancement"       # Requirements discovery
/sc:explain "complex system behavior"     # Concept clarification

# Best practice: Always start projects with discovery commands
# Time investment: 10-15 minutes upfront saves hours later

Development Commands (Active Coding):

# Use when: Implementing features, building components, coding
/sc:implement "specific feature with clear requirements"
/sc:design "system component" --type detailed
/sc:build --optimize --target production
/sc:improve code/ --type performance --measure-impact

# Best practice: Be specific in descriptions for better agent activation
# Example: Instead of "add auth", use "implement JWT authentication with rate limiting"

Quality Commands (Validation and Improvement):

# Use when: Code review, refactoring, optimization, testing
/sc:test --coverage --validate
/sc:analyze . --focus security --think-hard
/sc:cleanup . --safe-mode
/sc:document . --scope project

# Best practice: Run quality commands before commits and deployments
# Automation: Integrate into CI/CD pipelines for consistent quality

Workflow Commands (Project Management):

# Use when: Planning, coordination, complex projects
/sc:workflow "large feature implementation"
/sc:task "project milestone" --breakdown
/sc:spawn "complex system development" --parallel
/sc:estimate "development effort" --detailed

# Best practice: Use workflow commands for >3 step processes
# Planning time: 5 minutes of planning saves 30 minutes of execution

Command Optimization Strategies

Scope Optimization for Performance:

# Inefficient: Broad scope causing slowdowns
/sc:analyze . --scope project             # Analyzes entire project

# Optimized: Targeted scope for speed
/sc:analyze src/components/ --focus quality    # Specific directory
/sc:analyze auth.py --scope file               # Single file analysis
/sc:analyze api/ --focus security --scope module  # Focused analysis

# Performance gains: Faster execution with targeted scope

Context-Aware Command Selection:

# For new projects: Discovery-first approach
/sc:brainstorm → /sc:design → /sc:workflow → /sc:implement

# For existing projects: Analysis-first approach  
/sc:load → /sc:analyze → /sc:improve → /sc:test

# For debugging: Systematic approach
/sc:troubleshoot → /sc:analyze --focus problem-area → /sc:implement fix

# For optimization: Measure-first approach
/sc:analyze --focus performance → /sc:improve --measure-impact → /sc:test --benchmark

Command Chaining for Efficiency:

# Sequential chaining for dependent operations
/sc:design "API architecture" && /sc:implement "API endpoints" && /sc:test --api-validation

# Parallel chaining for independent operations
/sc:analyze frontend/ --focus performance & /sc:analyze backend/ --focus security & wait

# Conditional chaining for quality gates
/sc:test --coverage && /sc:analyze --focus quality && /sc:improve --safe-mode

# Time savings: Reduced total workflow time through efficient chaining

Basic Flag Usage

Essential Flag Combinations

Development Efficiency Flags:

# For rapid prototyping
/sc:implement "MVP feature" --scope module --validate
# --scope module: Limited scope for speed
# --validate: Verify changes before applying

# For learning and exploration
/sc:explain "complex architecture" --brainstorm
# --brainstorm: Interactive learning through dialogue

# Development speed: Faster iteration cycles through focused scope

Quality-Focused Flags:

# For production-ready development
/sc:implement "payment processing" --validate --safe-mode
# --validate: Pre-execution validation and risk assessment
# --safe-mode: Maximum safety checks and rollback capability

# For comprehensive analysis
/sc:analyze . --think --focus security
# --think: Standard structured analysis (~4K tokens)
# --focus security: Domain-specific expertise

# Quality improvements: Better validation through systematic checks

Performance-Oriented Flags:

# For large codebases (>10 files)
/sc:analyze project/ --scope module --concurrency 2
# --scope module: Limit analysis boundaries
# --concurrency 2: Basic parallel processing

# For resource-conscious development
/sc:implement "feature" --safe-mode
# --safe-mode: Conservative execution with validation

# Performance gains: Faster execution through optimized scope

Flag Selection Strategy

Context-Adaptive Flag Selection:

# Early development phase
/sc:brainstorm "new feature" --scope project
# Focus on exploration and requirements discovery

# Implementation phase
/sc:implement "feature" --validate
# Quality gates without over-optimization

# Testing phase
/sc:test . --coverage --validate
# Comprehensive validation with safety

# Maintenance phase
/sc:improve legacy-code/ --safe-mode --validate
# Conservative improvements with comprehensive testing

For detailed flag documentation, see Flags Guide.

Session Management Basics

Simple Session Workflows

Basic Session Pattern:

# Session start
/sc:load "project-name"                  # Restore previous context
/sc:reflect "current state"              # Understand where you left off

# Work session
/sc:implement "today's feature"          # Execute planned work
/sc:test --validate                      # Ensure quality

# Session end
/sc:save "progress-$(date +%m%d)"       # Save current state

Daily Development Cycle:

# Morning startup (2 minutes)
/sc:load "current-project"               # Restore context
/sc:workflow "today's priorities"        # Plan daily work

# Development work
/sc:implement "priority task"            # Execute development
/sc:test --coverage                      # Validate changes

# End of day (1 minute)
/sc:save "daily-$(date +%m%d)"         # Preserve progress

Context Preservation

Checkpoint Strategy:

# Before major changes
/sc:save "before-refactor"               # Create restore point

# After completing features
/sc:save "feature-auth-complete"         # Mark completion

# At natural breakpoints
/sc:save "midday-checkpoint"             # Regular progress saves

# Best practice: Save every 30-60 minutes during active development

Session Naming Conventions:

# Descriptive session names
/sc:save "auth-module-complete"          # Feature completion
/sc:save "bug-fix-payment-flow"          # Bug resolution
/sc:save "sprint-3-baseline"             # Sprint milestones
/sc:save "before-major-refactor"         # Safety checkpoints

# Date-based sessions
/sc:save "daily-$(date +%Y%m%d)"        # Daily progress
/sc:save "weekly-$(date +%U)"           # Weekly milestones

Daily Workflow Patterns

Proven Development Routines

Morning Startup Routine (5 minutes):

# Step 1: Context restoration
/sc:load "yesterday-end"                 # Restore work context

# Step 2: Review and planning
/sc:reflect "progress and priorities"    # Understand current state
/sc:workflow "today's objectives"        # Plan daily goals

# Step 3: Ready to develop
# Context established, priorities clear, ready for productive work

Feature Development Pattern:

# Step 1: Understanding
/sc:analyze . --scope module             # Understand current code

# Step 2: Planning
/sc:design "feature specification"       # Plan implementation

# Step 3: Implementation
/sc:implement "specific feature"         # Build the feature

# Step 4: Validation
/sc:test --coverage --validate           # Ensure quality

# Step 5: Documentation
/sc:document feature/ --scope module     # Document changes

End-of-Day Routine (3 minutes):

# Step 1: Final testing
/sc:test . --quick --validate            # Ensure working state

# Step 2: Progress documentation
/sc:reflect "today's accomplishments"    # Summarize progress

# Step 3: Context preservation
/sc:save "end-$(date +%m%d)"            # Save session state

# Benefits: Clean handoff to tomorrow, no lost context

Quick Problem Resolution

Debugging Workflow:

# Step 1: Problem identification
/sc:analyze problematic-area/ --focus issue

# Step 2: Root cause analysis
/sc:troubleshoot "specific error or behavior"

# Step 3: Solution implementation
/sc:implement "targeted fix" --validate

# Step 4: Verification
/sc:test . --focus affected-area

Code Quality Issues:

# Quick quality assessment
/sc:analyze . --focus quality --quick

# Targeted improvements
/sc:improve problematic-files/ --safe-mode

# Validation
/sc:test --coverage --validate

First Week Learning Path

Day-by-Day Progression

Day 1: Foundation Setup

• Install and configure SuperClaude
• Practice basic /sc:analyze and /sc:implement commands
• Learn session save/load basics
• Goal: Comfort with core commands

Day 2: Project Understanding

• Load an existing project with /sc:load
• Practice project analysis with --scope flags
• Experiment with focused analysis
• Goal: Project comprehension skills

Day 3: Feature Development

• Implement a simple feature end-to-end
• Practice test-driven development with /sc:test
• Learn basic error handling
• Goal: Complete development cycle

Day 4: Quality Practices

• Focus on code quality with /sc:improve
• Practice security analysis
• Learn documentation generation
• Goal: Quality-conscious development

Day 5: Workflow Optimization

• Practice command chaining
• Experiment with workflow planning
• Learn efficient flag combinations
• Goal: Workflow efficiency

Day 6: Session Management

• Practice long-term project workflows
• Learn checkpoint strategies
• Experiment with context preservation
• Goal: Project continuity skills

Day 7: Integration and Review

• Combine all learned concepts
• Complete a mini-project end-to-end
• Reflect on learning and optimization
• Goal: Integrated workflow confidence

Skill Development Milestones

Week 1 Success Criteria:

• Comfortable with daily SuperClaude workflow
• Can analyze and implement features independently
• Understands basic optimization principles
• Uses session management effectively

Week 2 Goals:

• Master agent coordination basics
• Understand behavioral mode optimization
• Practice complex project workflows
• Develop personal workflow patterns

Week 3 Goals:

• Integrate advanced flags effectively
• Practice multi-agent coordination
• Optimize for specific development contexts
• Share knowledge with team members

Common Quick Fixes

Immediate Problem Resolution

Scope Issues:

# Problem: Analysis taking too long
❌ /sc:analyze massive-project/

# Quick fix: Limit scope
✅ /sc:analyze src/ --scope directory
✅ /sc:analyze problematic-file.js --scope file

Command Clarity:

# Problem: Vague requests causing confusion
❌ /sc:implement "user stuff"

# Quick fix: Be specific
✅ /sc:implement "user authentication with JWT tokens"
✅ /sc:implement "user profile editing form"

Session Management:

# Problem: Lost work context
❌ Starting new sessions without loading context

# Quick fix: Always load previous work
✅ /sc:load "last-session"
✅ /sc:reflect "current state"

Quality Issues:

# Problem: Code not meeting standards
❌ Implementing without quality checks

# Quick fix: Add validation
✅ /sc:implement "feature" --validate
✅ /sc:test --coverage after implementation

Performance Quick Wins

Faster Analysis:

# Use targeted scope instead of project-wide analysis
/sc:analyze specific-area/ --scope module

Efficient Development:

# Combine related operations
/sc:implement "feature" && /sc:test --validate

Resource Management:

# Use safe-mode for resource-conscious development
/sc:improve . --safe-mode

Quick Reference Cards

Essential Commands Quick Reference

# Project Understanding
/sc:load project/                        # Load project context
/sc:analyze . --scope module             # Understand code structure
/sc:explain "complex concept"            # Get explanations

# Development
/sc:implement "specific feature"         # Build features
/sc:design "component spec"              # Plan implementations
/sc:improve . --focus quality            # Enhance code quality

# Quality Assurance
/sc:test --coverage                      # Run comprehensive tests
/sc:analyze . --focus security           # Security assessment
/sc:document . --scope project           # Generate documentation

# Session Management
/sc:save "session-name"                  # Save current state
/sc:load "session-name"                  # Restore previous state
/sc:reflect "current progress"           # Review and plan

Essential Flags Quick Reference

# Scope Control
--scope file                             # Single file focus
--scope module                           # Module-level focus
--scope project                          # Project-wide analysis

# Quality Control
--validate                               # Pre-execution validation
--safe-mode                              # Maximum safety checks
--coverage                               # Include test coverage

# Performance
--quick                                  # Fast analysis mode
--concurrency 2                         # Basic parallel processing

Daily Workflow Quick Reference

# Morning (5 min)
/sc:load "yesterday" && /sc:workflow "today's goals"

# Development (ongoing)
/sc:implement "feature" && /sc:test --validate

# Evening (3 min)
/sc:save "today-$(date +%m%d)" && /sc:reflect "progress"

Next Steps

Once you've mastered these quick start practices, explore more advanced capabilities:

Intermediate Level:

• Advanced Patterns - Multi-agent coordination and complex workflows
• Examples Cookbook - Real-world scenario practice

Advanced Level:

• Optimization Guide - Performance and efficiency mastery
• MCP Servers Guide - Enhanced tool integration

Expert Level:

• Technical Architecture - Deep system understanding
• Contributing Code - Framework development

Community Resources

Learning Support:

• GitHub Discussions - Community help and tips
• Troubleshooting Guide - Common issue resolution

Practice Materials:

• Examples Cookbook - Copy-paste solutions for common scenarios
• User Guide - Comprehensive feature documentation

---

Your Quick Start Journey:

Focus on building solid foundations before advancing to complex features. These practices provide immediate productivity gains while establishing patterns for long-term success.

Success Metrics:

• Week 1: Comfortable with basic workflows and daily routines
• Week 2: Independent feature development with quality practices
• Week 3: Confident session management and context preservation
• Week 4: Ready for advanced coordination and optimization techniques

Remember: Start simple, practice consistently, and gradually increase complexity as your confidence grows.