Sprint Planner - Capacity-Based Sprint Management

Purpose

This skill provides the lead-developer (Orchestrator) with a deterministic tool to perform sprint planning, manage team capacity, and update the state of the Markdown Contract database to reflect the new sprint. It implements intelligent task selection based on priority, dependencies, and story point constraints.

When to Use

• Sprint Planning: When starting a new sprint and need to select tasks
• Capacity Management: When managing team workload and resource allocation
• Task Prioritization: When ordering work based on business value and dependencies
• Sprint Retrospective: When analyzing sprint planning effectiveness
• Resource Planning: When forecasting team capacity and delivery timelines

R&D Workflow

This skill follows the "Reduce and Delegate" philosophy:

1. Agent Role: Primary tool for the lead-developer (Orchestrator agent)
2. Input: Sprint capacity (story points), sprint ID, and optional priority filters
3. Delegation: The agent MUST delegate the complex planning logic to ProjectWorkflowManager.plan_sprint()
4. Deterministic Process: The script performs reliable task selection and status updates

Input Requirements

The skill accepts structured sprint planning parameters:

{
  "sprint_id": "Sprint-01",
  "capacity": 50,
  "priority_filter": ["critical", "high"],
  "team_velocity": 45,
  "buffer_percentage": 20,
  "dependencies_resolved": true,
  "include_risks": true
}

Parameters Explained

• sprint_id: Unique identifier for the sprint (e.g., "Sprint-01", "Sprint-Q1-2025")
• capacity: Total story points the team can handle in this sprint
• priority_filter: Optional list of priorities to include (defaults to all)
• team_velocity: Historical team velocity for reference
• buffer_percentage: Percentage of capacity to reserve for unexpected work
• dependencies_resolved: Whether to only include tasks with resolved dependencies
• include_risks: Whether to include risk assessment in planning

Output Format

Returns comprehensive sprint planning results:

{
  "sprint_id": "Sprint-01",
  "capacity": 50,
  "utilized_capacity": 48,
  "remaining_capacity": 2,
  "tasks_selected": [
    {
      "id": "TASK-001",
      "title": "Implement Player Physics System",
      "story_points": 8,
      "priority": "critical",
      "assignee": "gdscript-engineer",
      "dependencies": [],
      "risk_level": "low",
      "estimated_completion": "3 days"
    },
    {
      "id": "TASK-015",
      "title": "Convert Ship Models to GLB Format",
      "story_points": 13,
      "priority": "high",
      "assignee": "asset-pipeline-engineer",
      "dependencies": ["TASK-014"],
      "risk_level": "medium",
      "estimated_completion": "5 days"
    }
  ],
  "total_tasks": 6,
  "total_points": 48,
  "priority_distribution": {
    "critical": 2,
    "high": 3,
    "medium": 1,
    "low": 0
  },
  "assignee_distribution": {
    "gdscript-engineer": 3,
    "asset-pipeline-engineer": 2,
    "ui-engineer": 1
  },
  "unestimated_tasks": ["TASK-007", "TASK-023"],
  "deferred_tasks": [
    {
      "id": "TASK-042",
      "reason": "Insufficient capacity",
      "story_points": 8,
      "priority": "medium"
    }
  ],
  "risk_assessment": {
    "overall_risk": "medium",
    "high_risk_tasks": ["TASK-015"],
    "dependency_risks": [],
    "capacity_risk": "low"
  },
  "recommendations": [
    "Consider splitting TASK-015 into smaller tasks",
    "Estimate story points for unestimated tasks before next sprint"
  ],
  "errors": []
}

Deterministic Planning Algorithm

The ProjectWorkflowManager backend implements this planning process:

Phase 1: Task Filtering

1. Status Filter: Select tasks with status: pending
2. Priority Filter: Apply optional priority filter
3. Dependency Check: Verify task dependencies are resolved (if required)
4. Estimation Filter: Exclude tasks with story_points: 0

Phase 2: Task Sorting

1. Primary Sort: By priority score (critical=4, high=3, medium=2, low=1)
2. Secondary Sort: By story points (smaller tasks first for quick wins)
3. Tertiary Sort: By dependency count (tasks with fewer dependencies first)

Phase 3: Capacity Management

1. Buffer Allocation: Reserve capacity for unexpected work
2. Task Selection: Iteratively select tasks within remaining capacity
3. Dependency Validation: Ensure selected tasks have no unresolved dependencies
4. Capacity Optimization: Maximize value while respecting constraints

Phase 4: Status Updates

1. Database Update: Update task status to in_sprint
2. Sprint Assignment: Set sprint_id field for selected tasks
3. Timestamp Update: Update last_updated field
4. Audit Trail: Log planning decisions for future reference

Priority-Based Selection Strategy

Priority Scoring

• Critical (4 points): Security vulnerabilities, blocking issues, critical functionality
• High (3 points): Important features, performance improvements, user-facing changes
• Medium (2 points): Enhancements, technical debt, internal improvements
• Low (1 point): Nice-to-have features, minor improvements, research tasks

Selection Rules

1. Capacity First: Never exceed sprint capacity
2. Priority Weighting: Higher priority tasks selected first
3. Dependency Respect: Don't select tasks with unresolved dependencies
4. Balance Consideration: Maintain healthy mix of task types and complexities
5. Risk Management: Limit high-risk tasks per sprint

Capacity Management Best Practices

Capacity Planning

1. Historical Data: Use team velocity from previous sprints
2. Buffer Allocation: Reserve 15-20% capacity for unexpected work
3. Team Availability: Consider vacations, holidays, and team member availability
4. Complexity Factor: Adjust capacity based on task complexity

Story Point Estimation

1. Relative Sizing: Use Fibonacci sequence (1, 2, 3, 5, 8, 13)
2. Team Consensus: Ensure team agrees on estimates
3. Velocity Tracking: Monitor actual vs. estimated completion times
4. Estimation Reviews: Regularly review and calibrate estimates

Risk Assessment Framework

Task Risk Categories

1. Technical Risk: Unfamiliar technology, complex algorithms, integration challenges
2. Dependency Risk: External dependencies, cross-team coordination
3. Resource Risk: Skill gaps, tool availability, environment setup
4. Schedule Risk: Tight deadlines, parallel work, learning curves

Risk Mitigation Strategies

1. Spike Tasks: Time-boxed research for high-risk items
2. Parallel Development: Work on independent components simultaneously
3. Early Validation: Validate assumptions early in the sprint
4. Buffer Tasks: Keep small, low-risk tasks available for schedule adjustments

Integration with Markdown Contract Database

Task Status Updates

The skill updates these fields in the Markdown Contract:

• status: Changed from pending to in_sprint
• sprint_id: Set to the current sprint identifier
• last_updated: Updated with current timestamp

Dependency Validation

• Checks dependencies array in task frontmatter
• Verifies all dependency tasks have status: completed
• Flags tasks with unresolved dependencies for exclusion

Story Point Validation

• Reads story_points field from task frontmatter
• Excludes tasks with story_points: 0 (unestimated)
• Maintains running total of selected story points

Sprint Planning Reports

Executive Summary

• Sprint capacity utilization
• Task count and priority distribution
• Risk assessment and mitigation strategies
• Recommendations for improvement

Detailed Task Breakdown

• Selected tasks with full details
• Deferred tasks with reasons
• Unestimated tasks requiring attention
• Dependency analysis

Capacity Analysis

• Utilization vs. available capacity
• Assignee workload distribution
• Priority distribution analysis
• Historical comparison

Error Handling

The skill provides detailed error reporting for common issues:

{
  "error": "insufficient_capacity",
  "message": "No tasks can fit within available capacity",
  "suggestion": "Consider increasing capacity or breaking down large tasks",
  "details": {
    "available_capacity": 10,
    "smallest_task_points": 13,
    "unestimated_tasks": 5
  }
}

Best Practices

Pre-Sprint Preparation

1. Task Refinement: Ensure all tasks have clear acceptance criteria
2. Estimation Completeness: Verify story points are estimated for all tasks
3. Dependency Resolution: Resolve or document all task dependencies
4. Risk Assessment: Identify and plan for high-risk tasks

Sprint Planning

1. Capacity Realism: Set realistic capacity based on team velocity
2. Priority Alignment: Align sprint goals with business priorities
3. Dependency Management: Plan tasks in dependency order
4. Risk Balancing: Balance high-risk and low-risk tasks

Post-Sprint Analysis

1. Variance Analysis: Compare planned vs. actual completion
2. Estimation Accuracy: Review story point estimation accuracy
3. Velocity Tracking: Monitor and update team velocity
4. Process Improvement: Identify and implement process improvements

This skill provides deterministic, reliable sprint planning that integrates seamlessly with the Markdown Contract database and supports data-driven decision making for agile development processes.