sparc-methodology

DNYoussef's avatarfrom DNYoussef

SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) delivery framework with explicit constraints, checkpoints, and confidence ceilings.

⭐8stars🔀2forks📁View on GitHub🕐Updated Jan 4, 2026
[Architecture Design]

When & Why to Use This Skill

The SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) methodology is a high-performance delivery framework designed for systematic software development. It integrates multi-agent orchestration and Test-Driven Development (TDD) to ensure production-grade code quality through explicit constraints, evidence-based validation, and structured checkpoints.

Use Cases

  • Complex Software Engineering: Breaking down multi-faceted technical challenges into a structured five-phase workflow to ensure comprehensive requirement coverage and system integrity.
  • Multi-Agent Orchestration: Coordinating specialized AI agents to work concurrently on different modules, achieving significant speed improvements (2.8x-4.4x) in the development lifecycle.
  • Test-Driven Development (TDD) Implementation: Enforcing a 'tests-first' approach where specifications and architecture are validated against automated tests before final code completion.
  • Production-Ready Architecture Planning: Creating detailed architectural blueprints and pseudocode to prevent technical debt and ensure scalability in high-stakes environments.

/============================================================================/ /* SPARC-METHODOLOGY SKILL :: VERILINGUA x VERIX EDITION / /============================================================================*/

name: sparc-methodology version: 2.7.0 description: | [assert|neutral] SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) comprehensive development methodology with multi-agent orchestration [ground:given] [conf:0.95] [state:confirmed] category: development tags:

  • sparc
  • tdd
  • architecture
  • orchestration
  • methodology author: Claude Flow cognitive_frame: primary: aspectual goal_analysis: first_order: "Execute sparc-methodology workflow" second_order: "Ensure quality and consistency" third_order: "Enable systematic development processes"

/----------------------------------------------------------------------------/ /* S0 META-IDENTITY / /----------------------------------------------------------------------------*/

[define|neutral] SKILL := { name: "sparc-methodology", category: "development", version: "2.7.0", layer: L1 } [ground:given] [conf:1.0] [state:confirmed]

/----------------------------------------------------------------------------/ /* S1 COGNITIVE FRAME / /----------------------------------------------------------------------------*/

[define|neutral] COGNITIVE_FRAME := { frame: "Aspectual", source: "Russian", force: "Complete or ongoing?" } [ground:cognitive-science] [conf:0.92] [state:confirmed]

Kanitsal Cerceve (Evidential Frame Activation)

Kaynak dogrulama modu etkin.

/----------------------------------------------------------------------------/ /* S2 TRIGGER CONDITIONS / /----------------------------------------------------------------------------*/

[define|neutral] TRIGGER_POSITIVE := { keywords: ["sparc-methodology", "development", "workflow"], context: "user needs sparc-methodology capability" } [ground:given] [conf:1.0] [state:confirmed]

/----------------------------------------------------------------------------/ /* S3 CORE CONTENT / /----------------------------------------------------------------------------*/

SPARC Methodology - Comprehensive Development Framework

Kanitsal Cerceve (Evidential Frame Activation)

Kaynak dogrulama modu etkin.

When to Use This Skill

  • Domain-Specific Work: Tasks requiring specialized domain knowledge
  • Complex Problems: Multi-faceted challenges needing systematic approach
  • Best Practice Implementation: Following industry-standard methodologies
  • Quality-Critical Work: Production code requiring high standards
  • Team Collaboration: Coordinated work following shared processes

When NOT to Use This Skill

  • Outside Domain: Tasks outside this skill specialty area
  • Incompatible Tech Stack: Technologies not covered by this skill
  • Simple Tasks: Trivial work not requiring specialized knowledge
  • Exploratory Work: Experimental code without production requirements

Success Criteria

  • Implementation complete and functional
  • Tests passing with adequate coverage
  • Code reviewed and approved
  • Documentation updated
  • Performance benchmarks met
  • Security considerations addressed
  • Deployed or integrated successfully

Edge Cases to Handle

  • Legacy Integration: Working with older codebases or deprecated APIs
  • Missing Dependencies: Unavailable libraries or external services
  • Version Conflicts: Dependency version incompatibilities
  • Data Issues: Malformed input or edge case data
  • Concurrency: Race conditions or synchronization challenges
  • Error Handling: Graceful degradation and recovery

Guardrails

  • NEVER skip testing to ship faster
  • ALWAYS follow domain-specific best practices
  • NEVER commit untested or broken code
  • ALWAYS document complex logic and decisions
  • NEVER hardcode sensitive data or credentials
  • ALWAYS validate input and handle errors gracefully
  • NEVER deploy without reviewing changes

Evidence-Based Validation

  • Automated tests passing
  • Code linter/formatter passing
  • Security scan completed
  • Performance within acceptable range
  • Manual testing completed
  • Peer review approved
  • Documentation reviewed

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
  2. Development Phases
  3. Available Modes
  4. Activation Methods
  5. Orchestration Patterns
  6. TDD Workflows
  7. Best Practices
  8. Integration Examples
  9. 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

/----------------------------------------------------------------------------/ /* S4 SUCCESS CRITERIA / /----------------------------------------------------------------------------*/

[define|neutral] SUCCESS_CRITERIA := { primary: "Skill execution completes successfully", quality: "Output meets quality thresholds", verification: "Results validated against requirements" } [ground:given] [conf:1.0] [state:confirmed]

/----------------------------------------------------------------------------/ /* S5 MCP INTEGRATION / /----------------------------------------------------------------------------*/

[define|neutral] MCP_INTEGRATION := { memory_mcp: "Store execution results and patterns", tools: ["mcp__memory-mcp__memory_store", "mcp__memory-mcp__vector_search"] } [ground:witnessed:mcp-config] [conf:0.95] [state:confirmed]

/----------------------------------------------------------------------------/ /* S6 MEMORY NAMESPACE / /----------------------------------------------------------------------------*/

[define|neutral] MEMORY_NAMESPACE := { pattern: "skills/development/sparc-methodology/{project}/{timestamp}", store: ["executions", "decisions", "patterns"], retrieve: ["similar_tasks", "proven_patterns"] } [ground:system-policy] [conf:1.0] [state:confirmed]

[define|neutral] MEMORY_TAGGING := { WHO: "sparc-methodology-{session_id}", WHEN: "ISO8601_timestamp", PROJECT: "{project_name}", WHY: "skill-execution" } [ground:system-policy] [conf:1.0] [state:confirmed]

/----------------------------------------------------------------------------/ /* S7 SKILL COMPLETION VERIFICATION / /----------------------------------------------------------------------------*/

[direct|emphatic] COMPLETION_CHECKLIST := { agent_spawning: "Spawn agents via Task()", registry_validation: "Use registry agents only", todowrite_called: "Track progress with TodoWrite", work_delegation: "Delegate to specialized agents" } [ground:system-policy] [conf:1.0] [state:confirmed]

/----------------------------------------------------------------------------/ /* S8 ABSOLUTE RULES / /----------------------------------------------------------------------------*/

[direct|emphatic] RULE_NO_UNICODE := forall(output): NOT(unicode_outside_ascii) [ground:windows-compatibility] [conf:1.0] [state:confirmed]

[direct|emphatic] RULE_EVIDENCE := forall(claim): has(ground) AND has(confidence) [ground:verix-spec] [conf:1.0] [state:confirmed]

[direct|emphatic] RULE_REGISTRY := forall(agent): agent IN AGENT_REGISTRY [ground:system-policy] [conf:1.0] [state:confirmed]

/----------------------------------------------------------------------------/ /* PROMISE / /----------------------------------------------------------------------------*/

[commit|confident] SPARC_METHODOLOGY_VERILINGUA_VERIX_COMPLIANT [ground:self-validation] [conf:0.99] [state:confirmed]