/sparc-methodology

name: sparc-methodology
description: |
  SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) comprehensive development methodology with multi-agent orchestration

SPARC Methodology - Comprehensive Development Framework

Overview

SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) is a systematic development methodology integrated with Claude Flow's multi-agent orchestration capabilities. It provides 17 specialized modes for comprehensive software development, from initial research through deployment and monitoring.

Table of Contents

1. [Core Philosophy](#core-philosophy) 2. [Development Phases](#development-phases) 3. [Available Modes](#available-modes) 4. [Activation Methods](#activation-methods) 5. [Orchestration Patterns](#orchestration-patterns) 6. [TDD Workflows](#tdd-workflows) 7. [Best Practices](#best-practices) 8. [Integration Examples](#integration-examples) 9. [Common Workflows](#common-workflows)

---

Core Philosophy

SPARC methodology emphasizes:

• **Systematic Approach**: Structured phases from specification to completion
• **Test-Driven Development**: Tests written before implementation
• **Parallel Execution**: Concurrent agent coordination for 2.8-4.4x speed improvements
• **Memory Integration**: Persistent knowledge sharing across agents and sessions
• **Quality First**: Comprehensive reviews, testing, and validation
• **Modular Design**: Clean separation of concerns with clear interfaces

Key Principles

1. **Specification Before Code**: Define requirements and constraints clearly 2. **Design Before Implementation**: Plan architecture and components 3. **Tests Before Features**: Write failing tests, then make them pass 4. **Review Everything**: Code quality, security, and performance checks 5. **Document Continuously**: Maintain current documentation throughout

---

Development Phases

Phase 1: Specification

**Goal**: Define requirements, constraints, and success criteria

• Requirements analysis
• User story mapping
• Constraint identification
• Success metrics definition
• Pseudocode planning

**Key Modes**: `researcher`, `analyzer`, `memory-manager`

Phase 2: Architecture

**Goal**: Design system structure and component interfaces

• System architecture design
• Component interface definition
• Database schema planning
• API contract specification
• Infrastructure planning

**Key Modes**: `architect`, `designer`, `orchestrator`

Phase 3: Refinement (TDD Implementation)

**Goal**: Implement features with test-first approach

• Write failing tests
• Implement minimum viable code
• Make tests pass
• Refactor for quality
• Iterate until complete

**Key Modes**: `tdd`, `coder`, `tester`

Phase 4: Review

**Goal**: Ensure code quality, security, and performance

• Code quality assessment
• Security vulnerability scanning
• Performance profiling
• Best practices validation
• Documentation review

**Key Modes**: `reviewer`, `optimizer`, `debugger`

Phase 5: Completion

**Goal**: Integration, deployment, and monitoring

• System integration
• Deployment automation
• Monitoring setup
• Documentation finalization
• Knowledge capture

**Key Modes**: `workflow-manager`, `documenter`, `memory-manager`

---

Available Modes

Core Orchestration Modes

`orchestrator`

Multi-agent task orchestration with TodoWrite/Task/Memory coordination.

**Capabilities**:

• Task decomposition into manageable units
• Agent coordination and resource allocation
• Progress tracking and result synthesis
• Adaptive strategy selection
• Cross-agent communication

**Usage**:

mcp__claude-flow__sparc_mode {
  mode: "orchestrator",
  task_description: "coordinate feature development",
  options: { parallel: true, monitor: true }
}

`swarm-coordinator`

Specialized swarm management for complex multi-agent workflows.

**Capabilities**:

• Topology optimization (mesh, hierarchical, ring, star)
• Agent lifecycle management
• Dynamic scaling based on workload
• Fault tolerance and recovery
• Performance monitoring

`workflow-manager`

Process automation and workflow orchestration.

**Capabilities**:

• Workflow definition and execution
• Event-driven triggers
• Sequential and parallel pipelines
• State management
• Error handling and retry logic

`batch-executor`

Parallel task execution for high-throughput operations.

**Capabilities**:

• Concurrent file operations
• Batch processing optimization
• Resource pooling
• Load balancing
• Progress aggregation

---

Development Modes

`coder`

Autonomous code generation with batch file operations.

**Capabilities**:

• Feature implementation
• Code refactoring
• Bug fixes and patches
• API development
• Algorithm implementation

**Quality Standards**:

• ES2022+ standards
• TypeScript type safety
• Comprehensive error handling
• Performance optimization
• Security best practices

**Usage**:

mcp__claude-flow__sparc_mode {
  mode: "coder",
  task_description: "implement user authentication with JWT",
  options: {
    test_driven: true,
    parallel_edits: true,
    typescript: true
  }
}

`architect`

System design with Memory-based coordination.

**Capabilities**:

• Microservices architecture
• Event-driven design
• Domain-driven design (DDD)
• Hexagonal architecture
• CQRS and Event Sourcing

**Memory Integration**:

• Store architectural decisions
• Share component specifications
• Maintain design consistency
• Track architectural evolution

**Design Patterns**:

• Layered architecture
• Microservices patterns
• Event-driven patterns
• Domain modeling
• Infrastructure as Code

**Usage**:

mcp__claude-flow__sparc_mode {
  mode: "architect",
  task_description: "design scalable e-commerce platform",
  options: {
    detailed: true,
    memory_enabled: true,
    patterns: ["microservices", "event-driven"]
  }
}

`tdd`

Test-driven development with comprehensive testing.

**Capabilities**:

• Test-fir