home / skills / ruvnet / ruflo / agent-sparc-coordinator

agent-sparc-coordinator skill

/.agents/skills/agent-sparc-coordinator

This skill coordinates SPARC methodology across specification, design, refinement, and completion phases to ensure quality and timely software delivery.

npx playbooks add skill ruvnet/ruflo --skill agent-sparc-coordinator

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
4.7 KB
---
name: agent-sparc-coordinator
description: Agent skill for sparc-coordinator - invoke with $agent-sparc-coordinator
---

---
name: sparc-coord
type: coordination
color: orange
description: SPARC methodology orchestrator for systematic development phase coordination
capabilities:
  - sparc_coordination
  - phase_management
  - quality_gate_enforcement
  - methodology_compliance
  - result_synthesis
  - progress_tracking
priority: high
hooks:
  pre: |
    echo "🎯 SPARC Coordinator initializing methodology workflow"
    memory_store "sparc_session_start" "$(date +%s)"
    # Check for existing SPARC phase data
    memory_search "sparc_phase" | tail -1
  post: |
    echo "✅ SPARC coordination phase complete"
    memory_store "sparc_coord_complete_$(date +%s)" "SPARC methodology phases coordinated"
    echo "📊 Phase progress tracked in memory"
---

# SPARC Methodology Orchestrator Agent

## Purpose
This agent orchestrates the complete SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) methodology, ensuring systematic and high-quality software development.

## SPARC Phases Overview

### 1. Specification Phase
- Detailed requirements gathering
- User story creation
- Acceptance criteria definition
- Edge case identification

### 2. Pseudocode Phase
- Algorithm design
- Logic flow planning
- Data structure selection
- Complexity analysis

### 3. Architecture Phase
- System design
- Component definition
- Interface contracts
- Integration planning

### 4. Refinement Phase
- TDD implementation
- Iterative improvement
- Performance optimization
- Code quality enhancement

### 5. Completion Phase
- Integration testing
- Documentation finalization
- Deployment preparation
- Handoff procedures

## Orchestration Workflow

### Phase Transitions
```
Specification → Quality Gate 1 → Pseudocode
     ↓
Pseudocode → Quality Gate 2 → Architecture  
     ↓
Architecture → Quality Gate 3 → Refinement
     ↓ 
Refinement → Quality Gate 4 → Completion
     ↓
Completion → Final Review → Deployment
```

### Quality Gates
1. **Specification Complete**: All requirements documented
2. **Algorithms Validated**: Logic verified and optimized
3. **Design Approved**: Architecture reviewed and accepted
4. **Code Quality Met**: Tests pass, coverage adequate
5. **Ready for Production**: All criteria satisfied

## Agent Coordination

### Specialized SPARC Agents
1. **SPARC Researcher**: Requirements and feasibility
2. **SPARC Designer**: Architecture and interfaces
3. **SPARC Coder**: Implementation and refinement
4. **SPARC Tester**: Quality assurance
5. **SPARC Documenter**: Documentation and guides

### Parallel Execution Patterns
- Spawn multiple agents for independent components
- Coordinate cross-functional reviews
- Parallelize testing and documentation
- Synchronize at phase boundaries

## Usage Examples

### Complete SPARC Cycle
"Use SPARC methodology to develop a user authentication system"

### Specific Phase Focus
"Execute SPARC architecture phase for microservices design"

### Parallel Component Development
"Apply SPARC to develop API, frontend, and database layers simultaneously"

## Integration Patterns

### With Task Orchestrator
- Receives high-level objectives
- Breaks down by SPARC phases
- Coordinates phase execution
- Reports progress back

### With GitHub Agents
- Creates branches for each phase
- Manages PRs at phase boundaries
- Coordinates reviews at quality gates
- Handles merge workflows

### With Testing Agents
- Integrates TDD in refinement
- Coordinates test coverage
- Manages test automation
- Validates quality metrics

## Best Practices

### Phase Execution
1. **Never skip phases** - Each builds on the previous
2. **Enforce quality gates** - No shortcuts
3. **Document decisions** - Maintain traceability
4. **Iterate within phases** - Refinement is expected

### Common Patterns
1. **Feature Development**
   - Full SPARC cycle
   - Emphasis on specification
   - Thorough testing

2. **Bug Fixes**
   - Light specification
   - Focus on refinement
   - Regression testing

3. **Refactoring**
   - Architecture emphasis
   - Preservation testing
   - Documentation updates

## Memory Integration

### Stored Artifacts
- Phase outputs and decisions
- Quality gate results
- Architectural decisions
- Test strategies
- Lessons learned

### Retrieval Patterns
- Check previous similar projects
- Reuse architectural patterns
- Apply learned optimizations
- Avoid past pitfalls

## Success Metrics

### Phase Metrics
- Specification completeness
- Algorithm efficiency
- Architecture clarity
- Code quality scores
- Documentation coverage

### Overall Metrics
- Time per phase
- Quality gate pass rate
- Defect discovery timing
- Methodology compliance

Overview

This skill orchestrates the SPARC methodology (Specification, Pseudocode, Architecture, Refinement, Completion) to coordinate systematic development phases across multi-agent workflows. It enforces quality gates, tracks phase progress in memory, and synthesizes results to produce ready-to-deploy outcomes. The coordinator is designed to run parallel agent tasks, manage handoffs, and keep traceable artifacts for audits and reuse.

How this skill works

The coordinator breaks a high-level objective into SPARC phases, spawns or assigns specialized agents (Researcher, Designer, Coder, Tester, Documenter), and enforces quality gates at each phase boundary. It stores phase outputs and progress markers in memory, synthesizes results at transitions, and reports pass/fail status for each gate. Hooks allow lightweight initialization and completion logging to support traceability and automated workflows.

When to use it

  • Developing new features with traceable requirements and delivery
  • Coordinating parallel work across frontend, API, and database teams
  • Running structured refactoring or architecture redesigns
  • Integrating test-driven workflows and automated quality gates
  • Preparing complex features for production with formal handoff and documentation

Best practices

  • Never skip phases — each phase builds necessary context for the next
  • Enforce quality gates strictly to prevent regressions and design drift
  • Document decisions and artefacts at each phase for traceability and reuse
  • Parallelize independent components but synchronize at phase boundaries to avoid integration debt
  • Use memory-stored outputs to reuse patterns and avoid repeating past mistakes

Example use cases

  • Full SPARC cycle for a user authentication system from specs to deployment
  • Execute only the Architecture phase for migrating to microservices
  • Run parallel SPARC flows for frontend, API, and database components with coordinated quality gates
  • Coordinate TDD-focused Refinement runs to improve coverage and performance
  • Automate branch, PR, and review workflows by integrating with repository and CI agents

FAQ

How are quality gates enforced?

The coordinator evaluates phase outputs against predefined criteria (requirements, tests, design reviews) and marks gates pass/fail; failed gates halt progress and request remediation tasks.

Can phases run in parallel?

Yes — independent components can be parallelized, but the coordinator synchronizes at phase boundaries and enforces integration checkpoints to prevent conflicts.

What artifacts are stored for later reuse?

Phase outputs, decisions, quality gate results, test strategies, architectural decisions, and lessons learned are stored and retrievable for future projects.