Epic Sprints

Epic Sprints Skill

Generate sprint breakdown with dependency graph and execution layers for epic workflows.

Purpose

Break down epic plans into parallelizable sprints with dependency analysis, API contract locking, and execution layer optimization.

When to Invoke

• During /epic Step 4 (Sprint Breakdown phase)
• After plan.md is complete and reviewed
• Invokes /tasks command with epic context

Sprint Breakdown Process

Invoke /tasks with epic context:

/tasks

The /tasks phase will:

1. Read plan.md to understand phases
2. Analyze complexity and identify sprint boundaries
3. Build dependency graph between sprints
4. Lock API contracts (OpenAPI schemas) for parallel work
5. Generate sprint-plan.md with execution layers

Sprint Plan Structure

<sprint_plan>
  <sprints>
    <sprint id="S01" name="auth-backend">
      <dependencies></dependencies>
      <estimated_hours>16</estimated_hours>
      <subsystems>backend, database</subsystems>
      <contracts_locked>
        <api_contract>contracts/api/auth-v1.yaml</api_contract>
      </contracts_locked>
    </sprint>

    <sprint id="S02" name="auth-frontend">
      <dependencies>S01</dependencies>
      <estimated_hours>20</estimated_hours>
      <subsystems>frontend</subsystems>
    </sprint>

    <sprint id="S03" name="auth-integration">
      <dependencies>S01, S02</dependencies>
      <estimated_hours>12</estimated_hours>
      <subsystems>backend, frontend</subsystems>
    </sprint>
  </sprints>

  <execution_layers>
    <layer num="1">
      <sprint_ids>S01</sprint_ids>
      <parallelizable>true</parallelizable>
    </layer>
    <layer num="2">
      <sprint_ids>S02</sprint_ids>
      <parallelizable>false</parallelizable>
      <depends_on_layer>1</depends_on_layer>
    </layer>
    <layer num="3">
      <sprint_ids>S03</sprint_ids>
      <parallelizable>false</parallelizable>
      <depends_on_layer>2</depends_on_layer>
    </layer>
  </execution_layers>
</sprint_plan>

Tasks Generation

Also generates tasks.xml:

• All tasks across all sprints
• Task-level dependencies
• Sprint assignments
• Acceptance criteria per task

API Contract Locking

For parallel sprint execution, API contracts must be locked:

1. Extract API boundaries from plan.md
2. Generate OpenAPI schemas in contracts/api/
3. Mark contracts as locked in sprint-plan.md
4. Sprints reference locked contracts for implementation

Commit Sprint Breakdown

# Extract metadata for commit message
SPRINT_COUNT=$(xmllint --xpath 'count(//sprint)' epics/${EPIC_SLUG}/sprint-plan.md)
LAYER_COUNT=$(xmllint --xpath 'count(//layer)' epics/${EPIC_SLUG}/sprint-plan.md)
CONTRACT_COUNT=$(find epics/${EPIC_SLUG}/contracts -name '*.yaml' | wc -l)
TASK_COUNT=$(xmllint --xpath 'count(//task)' epics/${EPIC_SLUG}/tasks.md)

# Commit sprint breakdown and contracts
git add epics/${EPIC_SLUG}/sprint-plan.md
git add epics/${EPIC_SLUG}/tasks.md
git add epics/${EPIC_SLUG}/contracts/
git commit -m "docs(epic-tasks): create sprint breakdown for ${EPIC_SLUG} (${SPRINT_COUNT} sprints)

Sprints: ${SPRINT_COUNT}
Layers: ${LAYER_COUNT}
Contracts locked: ${CONTRACT_COUNT}
Total tasks: ${TASK_COUNT}

Next: /implement-epic (parallel sprint execution)"

Alternative: /meta:enforce-git-commits --phase "epic-sprint-breakdown"

Dependency Graph Rules

1. No circular dependencies: Sprints cannot depend on each other cyclically
2. Layer assignment: Sprints in the same layer can run in parallel
3. Contract boundaries: Sprints in different layers communicating via API must have locked contracts
4. Resource constraints: Consider subsystem conflicts when parallelizing

Execution Layer Optimization

Goal: Maximize parallelization while respecting dependencies

Algorithm:

1. Start with sprints that have no dependencies (Layer 1)
2. Sprints depending only on Layer 1 → Layer 2
3. Continue until all sprints assigned
4. Mark layers as parallelizable if multiple sprints share the same layer

Example optimization:

Before: S01 → S02 → S03 → S04 (sequential, 4 layers)
After:  L1[S01, S03] → L2[S02, S04] (parallel, 2 layers, 2x speedup)

State Updates

After sprint breakdown:

phases:
  tasks:
    status: completed
    completed_at: { ISO_TIMESTAMP }

sprints:
  total: { SPRINT_COUNT }
  completed: 0
  failed: 0

layers:
  total: { LAYER_COUNT }
  completed: 0

Next Step

After sprint breakdown, proceed to /implement-epic for parallel sprint execution.