External/SuperClaude
1
0
Fork 0
mirror of https://github.com/SuperClaude-Org/SuperClaude_Framework.git synced 2025-12-29 16:16:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

📚 Major documentation cleanup: Fix CLI confusion and streamline content

Browse Source 
## Critical Fixes ✅
- **CLI Command Syntax**: Fixed all ambiguous `SuperClaude --version` → `python3 -m SuperClaude --version`
- **Architecture Clarity**: Verified dual architecture documentation (Python CLI + Context Framework)
- **External Dependencies**: Marked unverified APIs as experimental (TWENTYFIRST_API_KEY, MORPH_API_KEY)
- **Installation Instructions**: Clarified NPM package names with verification warnings

## Content Optimization 🗑️
- **Removed unnecessary files**:
  - optimization-guide.md (inappropriate for context files)
  - quick-start-practices.md (duplicate content)
  - Various outdated socratic learning components
- **Updated cross-references**: Fixed all broken links to point to existing, relevant content
- **Consolidated navigation**: Streamlined Reference/README.md documentation matrix

## Technical Accuracy 🎯
- **Command References**: All commands now specify exact usage context (terminal vs Claude Code)
- **Framework Nature**: Consistently explains SuperClaude as context framework, not executable software
- **Installation Verification**: Updated diagnostic scripts with correct Python CLI commands
- **MCP Configuration**: Marked experimental services appropriately

## Impact Summary 📊
- **Files Modified**: 15+ documentation files for accuracy and consistency
- **Files Removed**: 5+ unnecessary/duplicate files
- **Broken Links**: 0 (all cross-references updated)
- **User Clarity**: Significantly improved understanding of dual architecture

Result: Professional documentation that accurately represents SuperClaude's sophisticated
dual architecture (Python CLI installation system + Claude Code context framework).

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
NomenAK
2025-08-21 19:03:25 +02:00
parent c78d5f8c01
commit 41761f405c
43 changed files with 3098 additions and 23245 deletions
Download Patch File Download Diff File Expand all files Collapse all files

854
Docs/Reference/advanced-patterns.md
View File

@@ -1,731 +1,323 @@
# SuperClaude Advanced Patterns
**Expert-Level Coordination and Workflow Mastery**: Advanced multi-agent coordination, behavioral mode optimization, and complex project orchestration patterns for experienced SuperClaude users.
**Advanced Context Usage Patterns**: Sophisticated combinations of commands, agents, and flags for experienced SuperClaude users working on complex projects.
**Focus**: Multi-agent workflows, behavioral mode mastery, complex coordination patterns, and expert-level techniques.
**Remember**: SuperClaude provides context to Claude Code. All patterns here are about guiding Claude's behavior through context, not executing code or coordinating processes.
## Table of Contents
### Multi-Agent Mastery
- [Agent Coordination Excellence](#agent-coordination-excellence) - Advanced multi-agent workflow patterns
- [Agent Selection Optimization](#agent-selection-optimization) - Precise specialist activation strategies
- [Cross-Domain Coordination](#cross-domain-coordination) - Complex system integration patterns
### Context Combination Patterns
- [Multi-Agent Context Patterns](#multi-agent-context-patterns) - Combining multiple specialist contexts
- [Command Sequencing Patterns](#command-sequencing-patterns) - Effective command combinations
- [Flag Combination Strategies](#flag-combination-strategies) - Advanced flag usage
### Behavioral Intelligence
- [Behavioral Mode Mastery](#behavioral-mode-mastery) - Context optimization and mode control
- [Mode Transition Strategies](#mode-transition-strategies) - Dynamic adaptation patterns
- [Context-Adaptive Behaviors](#context-adaptive-behaviors) - Intelligent mode selection
### Workflow Patterns
- [Complex Project Patterns](#complex-project-patterns) - Large project approaches
- [Migration Patterns](#migration-patterns) - Legacy system modernization
- [Review and Audit Patterns](#review-and-audit-patterns) - Comprehensive analysis
### Complex Orchestration
- [Multi-Tool Orchestration](#multi-tool-orchestration) - Advanced MCP server coordination
- [Enterprise-Scale Patterns](#enterprise-scale-patterns) - Large-scale development workflows
- [Adaptive Learning Patterns](#adaptive-learning-patterns) - Continuous improvement strategies
## Multi-Agent Context Patterns
### See Also
- [Quick Start Practices](./quick-start-practices.md) - Foundation skills and basic workflows
- [Optimization Guide](./optimization-guide.md) - Performance and efficiency strategies
### Combining Specialist Contexts
## Agent Coordination Excellence
### Multi-Agent Workflow Optimization
**Frontend + Backend + Security Coordination:**
**Security + Backend Pattern:**
```bash
# Optimal coordination for full-stack features
/sc:implement "secure user dashboard with real-time updates"
# Security-focused backend development
@agents-security "define authentication requirements"
@agents-backend-architect "design API with security requirements"
/sc:implement "secure API endpoints"
# Automatic activation and coordination:
# 1. security-engineer: Establishes security requirements and authentication patterns
# 2. backend-architect: Designs API with security validation and real-time capabilities
# 3. frontend-architect: Creates responsive UI with security compliance
# 4. Context7 MCP: Provides official patterns for frameworks and security libraries
# Coordination benefits:
# - Security requirements integrated from the start
# - API design optimized for frontend consumption
# - Real-time features implemented with security considerations
# - Modern UI patterns with accessibility compliance
# Results: Improved security integration and faster development through coordination
# What happens:
# 1. Security context loaded first
# 2. Backend context added
# 3. Implementation guided by both contexts
# Note: Contexts combine in Claude's understanding, not in execution
```
**Performance + Architecture + DevOps Coordination:**
**Frontend + UX + Accessibility Pattern:**
```bash
# System optimization requiring multiple specialists
/sc:improve "microservices platform performance under load"
# Comprehensive frontend development
@agents-frontend-architect "design component architecture"
/sc:implement "accessible React components" --magic
@agents-quality-engineer "review accessibility compliance"
# Specialist coordination:
# 1. performance-engineer: Identifies bottlenecks and optimization opportunities
# 2. system-architect: Evaluates architectural patterns and service communication
# 3. devops-architect: Assesses infrastructure scaling and deployment optimization
# 4. Sequential MCP: Provides systematic analysis and hypothesis testing
# Outcomes: Comprehensive optimization across application and infrastructure layers
# Context layering:
# - Frontend patterns guide structure
# - Magic MCP may provide UI components (if configured)
# - Quality context ensures standards
```
**Quality + Security + Documentation Coordination:**
### Manual vs Automatic Agent Selection
**Explicit Control Pattern:**
```bash
# Production readiness with comprehensive validation
/sc:analyze . --focus security --comprehensive --export production-audit
# Manually control which contexts load
@agents-python-expert "implement data pipeline"
# Only Python context, no auto-activation
# Multi-agent validation:
# 1. security-engineer: Security audit and vulnerability assessment
# 2. quality-engineer: Quality metrics and testing completeness
# 3. technical-writer: Documentation completeness and clarity
# 4. All agents collaborate on production readiness checklist
# Value: Production-ready validation with comprehensive documentation
# vs Automatic selection
/sc:implement "Python data pipeline"
# May activate multiple agents based on keywords
```
### Advanced Agent Selection Patterns
**Keyword Strategy for Precise Agent Activation:**
**Override Auto-Selection:**
```bash
# Generic request (suboptimal agent selection)
/sc:implement "user system"
# May activate generic backend-architect only
# Optimized request (precise agent selection)
/sc:implement "secure user authentication with JWT, rate limiting, and audit logging"
# Activates: security-engineer + backend-architect + quality-engineer
# Keywords: "secure", "authentication", "rate limiting", "audit" trigger specialists
# Domain-specific optimization
/sc:implement "React TypeScript component library with Storybook and accessibility"
# Activates: frontend-architect + technical-writer + quality-engineer
# Keywords: "React", "TypeScript", "accessibility" ensure proper specialists
# Prevent unwanted agent activation
/sc:implement "simple utility" --no-mcp
@agents-backend-architect "keep it simple"
# Limits context to specified agent only
```
**Agent Hierarchy and Leadership Patterns:**
## Command Sequencing Patterns
### Progressive Refinement Pattern
```bash
# Security-led development (security requirements drive implementation)
/sc:implement "payment processing system" --lead-agent security-engineer
# Security-engineer establishes requirements, others implement within constraints
# Start broad, then focus
/sc:analyze project/
# General analysis
# Architecture-led development (design drives implementation)
/sc:design "microservices architecture" --lead-agent system-architect
/sc:implement "service implementation" --follow-architecture
# Architecture decisions guide all implementation choices
/sc:analyze project/core/ --focus architecture
# Focused on structure
# Performance-led optimization (performance requirements drive decisions)
/sc:improve "high-traffic API" --lead-agent performance-engineer
# Performance considerations prioritized in all optimization decisions
/sc:analyze project/core/auth/ --focus security --think-hard
# Deep security analysis
# Each command builds on previous context within the conversation
```
### Complex Project Coordination Examples
### Discovery to Implementation Pattern
**E-commerce Platform Development:**
```bash
# Phase 1: Architecture and Security Foundation
/sc:design "e-commerce platform architecture" --lead-agent system-architect
# system-architect + security-engineer + devops-architect coordination
# Complete feature development flow
/sc:brainstorm "feature idea"
# Explores requirements
# Phase 2: Core Service Implementation
/sc:implement "user authentication and authorization service"
# security-engineer + backend-architect + database specialist
/sc:design "feature architecture"
# Creates structure
# Phase 3: Frontend Development
/sc:implement "responsive product catalog with search and filtering"
# frontend-architect + ux-designer + performance-engineer
@agents-backend-architect "review design"
# Expert review
# Phase 4: Integration and Testing
/sc:test "complete e-commerce workflow" --comprehensive
# quality-engineer + security-engineer + performance-engineer
/sc:implement "feature based on design"
# Implementation follows design
# Agent coordination benefits:
# - Consistent security patterns across all services
# - Performance optimization integrated from design phase
# - Quality gates enforced throughout development
# - Documentation maintained by technical-writer throughout
/sc:test --validate
# Verification approach
```
**Legacy System Modernization:**
### Iterative Improvement Pattern
```bash
# Discovery and Analysis Phase
/sc:analyze legacy-system/ --comprehensive --modernization-assessment
# system-architect + refactoring-expert + security-engineer + performance-engineer
# Multiple improvement passes
/sc:analyze code/ --focus quality
# Identify issues
# Modernization Strategy
/sc:workflow "legacy modernization roadmap" --risk-assessment
# system-architect leads with support from all specialists
/sc:improve code/ --fix
# First improvement pass
# Incremental Implementation
/sc:implement "microservice extraction" --backward-compatible --safe-mode
# refactoring-expert + system-architect + quality-engineer coordination
@agents-refactoring-expert "suggest further improvements"
# Expert suggestions
# Results: Risk-managed modernization with quality and performance improvements
/sc:improve code/ --fix --focus maintainability
# Refined improvements
```
## Agent Selection Optimization
## Flag Combination Strategies
### Precision Activation Techniques
### Analysis Depth Control
**Technology-Specific Agent Patterns:**
```bash
# React/Frontend Development
/sc:implement "React component with TypeScript, testing, and Storybook documentation"
# Triggers: frontend-architect + technical-writer + quality-engineer
# Keywords: "React", "TypeScript", "testing", "Storybook" ensure comprehensive coverage
# Quick overview
/sc:analyze . --quick --uc
# Fast, compressed output
# Node.js/Backend Development
/sc:implement "Express API with authentication, rate limiting, and monitoring"
# Triggers: backend-architect + security-engineer + devops-architect
# Keywords: "Express", "authentication", "rate limiting", "monitoring" activate specialists
# Standard analysis
/sc:analyze . --think
# Structured thinking
# Database/Performance Optimization
/sc:improve "PostgreSQL query performance with indexing and connection pooling"
# Triggers: database-specialist + performance-engineer + system-architect
# Keywords: "PostgreSQL", "performance", "indexing", "connection pooling" ensure expertise
# Deep analysis
/sc:analyze . --think-hard --verbose
# Comprehensive analysis
# Maximum depth (use sparingly)
/sc:analyze . --ultrathink
# Exhaustive analysis
```
**Cross-Functional Team Patterns:**
```bash
# Full-Stack Feature Development
/sc:implement "real-time chat system with React frontend, WebSocket backend, and Redis"
# Auto-coordination between:
# - frontend-architect (React UI components)
# - backend-architect (WebSocket implementation)
# - system-architect (Redis integration)
# - performance-engineer (real-time optimization)
### MCP Server Selection
# DevOps and Security Integration
/sc:implement "CI/CD pipeline with security scanning, automated testing, and deployment"
# Auto-coordination between:
# - devops-architect (CI/CD design)
# - security-engineer (security scanning)
# - quality-engineer (automated testing)
# - system-architect (deployment strategy)
```bash
# Selective MCP usage
/sc:implement "React component" --magic --c7
# Only Magic and Context7 MCP
# Disable all MCP
/sc:implement "simple function" --no-mcp
# Pure Claude context only
# All available MCP
/sc:analyze complex-system/ --all-mcp
# Maximum tool availability (if configured)
```
### Expert Agent Coordination Strategies
## Complex Project Patterns
### Large Codebase Analysis
**Domain-Driven Agent Selection:**
```bash
# Financial Services (Security-First)
/sc:implement "payment processing with PCI compliance, fraud detection, and audit logging"
# Primary: security-engineer
# Supporting: backend-architect, quality-engineer, technical-writer
# Focus: Security and compliance drive all decisions
# Systematic exploration of large projects
# Step 1: Structure understanding
/sc:load project/
/sc:analyze . --quick --focus architecture
# High-Performance Systems (Performance-First)
/sc:implement "real-time trading platform with microsecond latency requirements"
# Primary: performance-engineer
# Supporting: system-architect, backend-architect, devops-architect
# Focus: Performance requirements drive architecture
# Step 2: Identify problem areas
@agents-quality-engineer "identify high-risk modules"
# Developer Tools (UX-First)
/sc:implement "developer CLI with intuitive commands, comprehensive help, and error handling"
# Primary: ux-designer
# Supporting: frontend-architect, technical-writer, quality-engineer
# Focus: Developer experience drives design
# Step 3: Deep dive into specific areas
/sc:analyze high-risk-module/ --think-hard --focus quality
# Step 4: Implementation plan
/sc:workflow "improvement plan based on analysis"
```
## Cross-Domain Coordination
### Multi-Module Development
### Complex System Integration
**Microservices Architecture Coordination:**
```bash
# Service Mesh Implementation
/sc:implement "microservices with Istio service mesh, monitoring, and security"
# Multi-domain coordination:
# - system-architect: Service mesh design and communication patterns
# - devops-architect: Kubernetes deployment and scaling
# - security-engineer: mTLS, RBAC, and security policies
# - performance-engineer: Latency optimization and load balancing
# - quality-engineer: Integration testing and service contracts
# Developing interconnected modules
# Frontend module
/sc:implement "user interface module"
@agents-frontend-architect "ensure consistency"
# Expected outcomes:
# - Cohesive architecture across all services
# - Consistent security policies and implementation
# - Performance optimization at system level
# - Comprehensive testing and monitoring strategy
# Backend module
/sc:implement "API module"
@agents-backend-architect "ensure compatibility"
# Integration layer
/sc:implement "frontend-backend integration"
# Context from both previous implementations guides this
```
**Cloud-Native Platform Development:**
```bash
# Multi-Cloud Platform Strategy
/sc:design "cloud-native platform with AWS, Azure, and GCP support"
# Specialist coordination:
# - system-architect: Multi-cloud architecture and abstraction layers
# - devops-architect: Infrastructure as code and deployment automation
# - security-engineer: Cloud security best practices and compliance
# - backend-architect: API design for cloud service integration
# - performance-engineer: Cross-cloud performance optimization
### Cross-Technology Projects
# Integration benefits:
# - Vendor-agnostic architecture design
# - Consistent deployment across cloud providers
# - Unified security model across platforms
# - Performance optimization for each cloud environment
```bash
# Projects with multiple technologies
# Python backend
@agents-python-expert "implement FastAPI backend"
# React frontend
@agents-frontend-architect "implement React frontend"
# DevOps setup
@agents-devops-architect "create deployment configuration"
# Integration documentation
/sc:document --type integration
```
### Enterprise Integration Patterns
## Migration Patterns
### Legacy System Analysis
**Legacy-to-Modern Integration:**
```bash
# Strangler Fig Pattern Implementation
/sc:implement "gradual legacy replacement with modern API gateway and event sourcing"
# Coordinated approach:
# - system-architect: Migration strategy and coexistence patterns
# - refactoring-expert: Legacy code analysis and extraction
# - backend-architect: Modern service design and API contracts
# - data-engineer: Data migration and consistency strategies
# - quality-engineer: Testing strategies for hybrid systems
# Understanding legacy systems
/sc:load legacy-system/
/sc:analyze . --focus architecture --verbose
# Migration benefits:
# - Risk-minimized modernization approach
# - Business continuity during transition
# - Gradual team skill development
# - Measurable progress and rollback capability
@agents-refactoring-expert "identify modernization opportunities"
@agents-system-architect "propose migration strategy"
/sc:workflow "create migration plan"
```
**Multi-Team Coordination:**
```bash
# Cross-Team Feature Development
/sc:spawn "enterprise customer portal spanning authentication, billing, and support"
# Team coordination pattern:
# - Team A (Auth): security-engineer + backend-architect
# - Team B (Billing): backend-architect + database-specialist
# - Team C (Support): frontend-architect + ux-designer
# - Integration: system-architect + quality-engineer across teams
### Incremental Migration
# Coordination outcomes:
# - Consistent API contracts across teams
# - Shared component libraries and patterns
# - Unified testing and deployment strategies
# - Cross-team knowledge sharing and standards
```bash
# Step-by-step migration approach
# Phase 1: Analysis
/sc:analyze legacy-module/ --comprehensive
# Phase 2: Design new architecture
@agents-system-architect "design modern replacement"
# Phase 3: Implementation
/sc:implement "modern module with compatibility layer"
# Phase 4: Validation
/sc:test --focus compatibility
```
## Behavioral Mode Mastery
## Review and Audit Patterns
### Strategic Mode Usage Patterns
### Security Audit Pattern
**Brainstorming Mode for Requirements Discovery:**
```bash
# Activate for: Vague requirements, project planning, creative exploration
/sc:brainstorm "productivity solution for remote teams"
# Triggers: uncertainty keywords ("maybe", "thinking about", "not sure")
# Expected behavior:
# - Socratic questioning approach
# - Requirements elicitation through dialogue
# - Creative problem exploration
# - Structured requirements document generation
# Optimal use cases:
# - Project kickoffs with unclear requirements
# - Feature ideation and planning sessions
# - Problem exploration and solution discovery
# - Stakeholder requirement gathering
# Results: Better requirement clarity and reduced scope changes
# Comprehensive security review
/sc:analyze . --focus security --think-hard
@agents-security "review authentication and authorization"
@agents-security "check for OWASP vulnerabilities"
/sc:document --type security-audit
```
**Task Management Mode for Complex Projects:**
### Code Quality Review
```bash
# Activate for: Multi-step projects, complex coordination, long-term development
/sc:implement "complete microservices platform with monitoring and security"
# Triggers: >3 steps, complex scope, multiple domains
# Expected behavior:
# - Hierarchical task breakdown (Plan → Phase → Task → Todo)
# - Progress tracking and session persistence
# - Cross-session context maintenance
# - Quality gates and validation checkpoints
# Optimal use cases:
# - Enterprise application development
# - System modernization projects
# - Multi-sprint feature development
# - Cross-team coordination initiatives
# Benefits: Improved project completion rates and higher quality through structured approach
# Multi-aspect quality review
/sc:analyze src/ --focus quality
@agents-quality-engineer "review test coverage"
@agents-refactoring-expert "identify code smells"
/sc:improve --fix --preview
```
**Orchestration Mode for High-Complexity Coordination:**
### Architecture Review
```bash
# Activate for: Multi-tool operations, performance constraints, parallel execution
/sc:spawn "full-stack platform with React, Node.js, PostgreSQL, Redis, Docker deployment"
# Triggers: complexity >0.8, multiple domains, resource optimization needs
# Expected behavior:
# - Intelligent tool selection and coordination
# - Parallel task execution optimization
# - Resource management and efficiency focus
# - Multi-agent workflow orchestration
# Optimal use cases:
# - Complex system integration
# - Performance-critical implementations
# - Multi-technology stack development
# - Resource-constrained environments
# Performance gains: Faster execution and better resource utilization through intelligent coordination
# System architecture assessment
@agents-system-architect "review current architecture"
/sc:analyze . --focus architecture --think-hard
@agents-performance-engineer "identify bottlenecks"
/sc:design "optimization recommendations"
```
### Manual Mode Control Strategies
## Important Clarifications
**Explicit Mode Activation:**
```bash
# Force brainstorming mode for systematic exploration
/sc:brainstorm "well-defined requirements" --mode brainstorming
# Override automatic mode selection when exploration needed
### What These Patterns Actually Do
# Force task management mode for simple tasks requiring tracking
/sc:implement "simple feature" --task-manage --breakdown
# Useful for learning task breakdown patterns
- ✅ **Guide Claude's Thinking**: Provide structured approaches
- ✅ **Combine Contexts**: Layer multiple expertise areas
- ✅ **Improve Output Quality**: Better code generation through better context
- ✅ **Structure Workflows**: Organize complex tasks
# Force introspection mode for learning and analysis
/sc:analyze "working solution" --introspect --learning-focus
# Enable meta-cognitive analysis for educational purposes
### What These Patterns Don't Do
# Force token efficiency mode for resource optimization
/sc:analyze large-project/ --uc --token-efficient
# Manual activation when context pressure anticipated
```
- ❌ **Execute in Parallel**: Everything is sequential context loading
- ❌ **Coordinate Processes**: No actual process coordination
- ❌ **Optimize Performance**: No code runs, so no performance impact
- ❌ **Persist Between Sessions**: Each conversation is independent
## Mode Transition Strategies
## Best Practices for Advanced Usage
### Dynamic Mode Adaptation
### Context Management
**Sequential Mode Progression for Complex Projects:**
```bash
# Phase 1: Brainstorming mode for discovery
Phase 1: /sc:brainstorm "project concept" --requirements-focus
# Mode: Collaborative discovery, requirements elicitation
1. **Layer Deliberately**: Add contexts in logical order
2. **Avoid Overload**: Too many agents can dilute focus
3. **Use Manual Control**: Override auto-activation when needed
4. **Maintain Conversation Flow**: Keep related work in same conversation
# Phase 2: Task management mode for structured development
Phase 2: /sc:workflow "project plan" --task-manage --breakdown
# Mode: Hierarchical planning, progress tracking, quality gates
### Command Efficiency
# Phase 3: Orchestration mode for integration
Phase 3: /sc:implement "core features" --orchestrate --parallel
# Mode: Multi-tool coordination, parallel execution, efficiency focus
1. **Progress Logically**: Broad → Specific → Implementation
2. **Reuse Context**: Later commands benefit from earlier context
3. **Document Decisions**: Use `/sc:save` for important summaries
4. **Scope Appropriately**: Focus on manageable chunks
# Phase 4: Introspection mode for optimization and learning
Phase 4: /sc:reflect "project completion" --introspect --lessons-learned
# Mode: Meta-cognitive analysis, process improvement, knowledge capture
### Flag Usage
# Each phase optimized for specific behavioral needs
```
1. **Match Task Complexity**: Simple tasks don't need `--ultrathink`
2. **Control Output**: Use `--uc` for concise results
3. **Manage MCP**: Only activate needed servers
4. **Avoid Conflicts**: Don't use contradictory flags
**Context-Sensitive Mode Selection:**
```bash
# Startup MVP Development Context
Week 1: /sc:brainstorm "SaaS platform for small businesses" # Discovery mode
Week 2-3: /sc:workflow "MVP development plan" --6-week-timeline # Task management
Week 4-5: /sc:spawn "frontend-backend integration" --orchestrate # Coordination mode
Week 6: /sc:reflect "MVP development process" --lessons-learned # Introspection
## Summary
# Enterprise Application Modernization Context
Discovery: /sc:analyze legacy-system/ --introspect --modernization-assessment
Planning: /sc:brainstorm "modernization approaches for legacy monolith"
Implementation: /sc:workflow "microservices extraction roadmap" --enterprise-scale
Integration: /sc:spawn "microservices deployment with monitoring" --orchestrate
Optimization: /sc:analyze complete-system/ --uc --performance-focus
```
### Advanced Mode Coordination
**Multi-Mode Project Workflows:**
```bash
# Open Source Contribution Workflow
Understanding: /sc:load open-source-project/ --introspect --contributor-perspective
# Deep understanding with transparent reasoning about project patterns
Planning: /sc:brainstorm "feature contribution that benefits community"
# Explore contribution opportunities with community value focus
Implementation: /sc:implement "community feature" --orchestrate --comprehensive
# High-quality implementation with community standards compliance
Review: /sc:workflow "pull request preparation" --task-manage --community-standards
# Structured approach to meet project contribution requirements
# Results: High-quality contributions aligned with community needs
```
## Context-Adaptive Behaviors
### Intelligent Context Recognition
**Project Phase Adaptation:**
```bash
# Early Development (Exploration Phase)
/sc:brainstorm "new product concept" --exploration-focus
# Mode automatically emphasizes:
# - Creative problem solving
# - Requirement discovery
# - Stakeholder dialogue
# - Solution space exploration
# Middle Development (Implementation Phase)
/sc:implement "core product features" --production-focus
# Mode automatically emphasizes:
# - Quality gates and validation
# - Performance considerations
# - Security integration
# - Testing and documentation
# Late Development (Optimization Phase)
/sc:improve "production system" --efficiency-focus
# Mode automatically emphasizes:
# - Performance optimization
# - Resource efficiency
# - Monitoring and observability
# - Maintenance considerations
```
**Team Context Adaptation:**
```bash
# Solo Developer Context
/sc:implement "personal project feature" --solo-optimization
# Behavior adapts for:
# - Rapid iteration cycles
# - Minimal documentation needs
# - Experimentation encouragement
# - Learning-focused feedback
# Team Development Context
/sc:implement "team project feature" --collaboration-optimization
# Behavior adapts for:
# - Code review preparation
# - Documentation standards
# - Team communication
# - Knowledge sharing
# Enterprise Context
/sc:implement "enterprise feature" --enterprise-optimization
# Behavior adapts for:
# - Compliance requirements
# - Security standards
# - Audit trails
# - Risk management
```
## Multi-Tool Orchestration
### Advanced MCP Server Coordination
**Comprehensive Analysis with Full Capability Stack:**
```bash
# Complex system analysis with coordinated intelligence
/sc:analyze distributed-system/ --ultrathink --all-mcp
# Activates coordinated intelligence:
# - Sequential MCP: Multi-step reasoning for complex system analysis
# - Context7 MCP: Official patterns and architectural best practices
# - Serena MCP: Project memory and historical decision context
# - Morphllm MCP: Code transformation and optimization patterns
# - Playwright MCP: Integration testing and validation scenarios
# - Magic MCP: UI optimization and component generation (if applicable)
# Expected outcomes:
# 1. Systematic analysis with evidence-based recommendations
# 2. Architecture patterns aligned with industry best practices
# 3. Historical context preserving previous architectural decisions
# 4. Automated optimization suggestions with measurable impact
# 5. Comprehensive testing scenarios for validation
# 6. Modern UI patterns integrated with system architecture
# Performance: More comprehensive analysis and better recommendations through coordination
```
**Specialized Tool Combinations:**
```bash
# Frontend Development Optimization
/sc:implement "React component library" --magic --c7 --seq
# Magic: Modern UI component generation
# Context7: Official React patterns and best practices
# Sequential: Systematic component architecture analysis
# Backend Performance Optimization
/sc:improve "API performance" --seq --morph --play
# Sequential: Systematic performance analysis
# Morphllm: Bulk optimization pattern application
# Playwright: Performance validation and testing
# Security Audit and Hardening
/sc:analyze . --focus security --c7 --seq --serena
# Context7: Official security patterns and compliance standards
# Sequential: Systematic threat modeling and analysis
# Serena: Historical security decision context and learning
```
### Intelligent Tool Selection
**Context-Driven Tool Coordination:**
```bash
# Large Codebase Modernization
/sc:improve legacy-monolith/ --serena --morph --seq
# Serena: Historical context and architectural understanding
# Morphllm: Bulk modernization pattern application
# Sequential: Systematic modernization planning and risk assessment
# Performance-Critical System Development
/sc:implement "high-frequency trading platform" --seq --c7 --play
# Sequential: Systematic performance analysis and optimization
# Context7: Industry performance patterns and best practices
# Playwright: Performance validation and load testing
# UI/UX Focused Development
/sc:implement "design system components" --magic --c7 --play
# Magic: Modern component generation with design patterns
# Context7: Official design system patterns and accessibility
# Playwright: Visual testing and accessibility validation
```
## Enterprise-Scale Patterns
### Multi-Team Coordination
**Cross-Team Development Orchestration:**
```bash
# Enterprise platform development coordination
/sc:spawn "enterprise platform development" --orchestrate
# Advanced coordination features:
# - Cross-team dependency management and coordination
# - Shared component library development and maintenance
# - Architectural consistency enforcement across teams
# - Quality standard alignment and cross-team validation
# - Documentation synchronization and knowledge sharing
# Implementation pattern:
Team A: /sc:implement "authentication service" --focus security --validate
Team B: /sc:implement "user interface" --magic --validate
Team C: /sc:implement "data analytics" --focus performance --validate
# Coordination benefits:
# - Reduced duplication across teams
# - Consistent architectural patterns
# - Shared quality standards and practices
# - Accelerated development through reuse
# - Enterprise-grade scalability and maintainability
```
**Shared Standards and Patterns:**
```bash
# Organization-Wide Standards Implementation
/sc:implement "company-wide design system with React, TypeScript, and testing"
# Activates enterprise coordination:
# - frontend-architect: Component architecture and patterns
# - technical-writer: Documentation standards and guidelines
# - quality-engineer: Testing standards and automation
# - ux-designer: Design consistency and accessibility
# Standards enforcement across projects:
/sc:analyze multiple-projects/ --focus standards-compliance --enterprise-audit
# Validates consistency across:
# - Code style and patterns
# - Security implementation
# - Testing coverage and quality
# - Documentation completeness
```
### Scalable Architecture Patterns
**Microservices Ecosystem Development:**
```bash
# Complete microservices platform with enterprise features
/sc:spawn "microservices platform with service mesh, monitoring, and governance"
# Comprehensive coordination:
# - system-architect: Service communication and data flow
# - devops-architect: Infrastructure and deployment automation
# - security-engineer: Service-to-service security and compliance
# - performance-engineer: Cross-service performance optimization
# - quality-engineer: Integration testing and service contracts
# Platform capabilities:
# - Service discovery and communication
# - Distributed tracing and monitoring
# - Security policy enforcement
# - Automated testing and deployment
# - Performance monitoring and optimization
```
## Adaptive Learning Patterns
### Continuous Improvement Strategies
**Learning-Oriented Development:**
```bash
# Advanced session management with optimization learning
/sc:load "long-term-project" --scope project
# Intelligent adaptation capabilities:
# - Development pattern analysis and efficiency optimization
# - Tool usage optimization based on project characteristics
# - Quality prediction and proactive issue prevention
# - Performance optimization based on historical bottlenecks
# - Risk assessment and mitigation based on project patterns
# Learning cycle implementation:
Week 1: /sc:reflect "development patterns and efficiency opportunities"
Week 2: /sc:implement "optimized workflow based on pattern analysis"
Week 3: /sc:analyze "workflow optimization impact measurement"
Week 4: /sc:workflow "refined development process for next iteration"
# Results: Continuous improvement and personalized optimization through systematic analysis
```
**Pattern Recognition and Optimization:**
```bash
# Historical Analysis for Process Improvement
/sc:analyze project-history/ --pattern-recognition --optimization-opportunities
# Identifies recurring patterns:
# - Common development bottlenecks and solutions
# - Most effective agent coordination patterns
# - Optimal tool selection for specific contexts
# - Quality improvement opportunities and prevention
# Predictive Optimization
/sc:implement "new feature" --predictive-optimization --learn-from-history
# Applies learned patterns:
# - Proactive quality gate implementation
# - Optimal tool selection based on feature characteristics
# - Risk mitigation based on historical patterns
# - Efficiency optimization from previous similar work
```
## Next Steps
Master these advanced patterns to become a SuperClaude expert:
**Immediate Application:**
- Practice multi-agent coordination on your current projects
- Experiment with behavioral mode optimization
- Apply complex orchestration patterns to enterprise scenarios
**Skill Development:**
- [Optimization Guide](./optimization-guide.md) - Performance and efficiency mastery
- [Technical Architecture](../Developer-Guide/technical-architecture.md) - Deep system understanding
**Leadership and Mentoring:**
- Train team members in advanced coordination patterns
- Develop organization-specific best practices
- Contribute to SuperClaude framework improvement
## Community Contribution
**Share Your Patterns:**
- Document successful coordination strategies
- Contribute to [Examples Cookbook](./examples-cookbook.md)
- Share insights in [GitHub Discussions](https://github.com/SuperClaude-Org/SuperClaude_Framework/discussions)
**Advanced Learning:**
- [Contributing Code](../Developer-Guide/contributing-code.md) - Framework development
- [Testing & Debugging](../Developer-Guide/testing-debugging.md) - Advanced optimization
---
**Your Advanced Journey:**
These patterns represent the cutting edge of SuperClaude capabilities. Master them to achieve enterprise-grade coordination, optimization, and development excellence.
**Mastery Indicators:**
- **Multi-Agent Fluency**: Seamless coordination across multiple specialists
- **Mode Mastery**: Intelligent adaptation to context and requirements
- **Tool Orchestration**: Optimal MCP server combinations for complex scenarios
- **Enterprise Impact**: Measurable improvements in team productivity and quality
Advanced SuperClaude patterns are about sophisticated context management and command sequencing. They help Claude Code generate better outputs by providing richer, more structured context. Remember: all "coordination" and "optimization" happens in how Claude interprets the context, not in any actual execution or parallel processing.