Sprint Planning Fast

The Sprint Planning Fast command facilitates sprint planning by analyzing the current backlog, team capacity, historical velocity, and task dependencies to produce an optimized sprint plan. It prioritizes work items, balances workload across team members, identifies scheduling risks, and generates a sprint commitment that aligns capacity with deliverables. Run this command at the start of each sprint to transform an unstructured backlog into a focused, achievable plan.

When to Use This Command

Run this command when...

• You are starting a new sprint and need to select, prioritize, and assign work items from the backlog based on team capacity
• You want to balance the workload across team members based on their availability, expertise, and current assignments
• You need to identify task dependencies that constrain scheduling and determine which items must be completed before others can start
• You are evaluating whether a proposed sprint scope is achievable given the team's historical velocity and current capacity
• You want to generate a sprint plan document that the team can review, discuss, and commit to during the planning meeting

Consider alternatives when...

• You need to estimate individual tasks, which the estimation command handles with complexity analysis and historical comparison
• You are conducting a retrospective on the completed sprint, which the retrospective analyzer command addresses
• Your team does not use sprints and follows a continuous flow or Kanban methodology

Quick Start

Copy
# sprint-planning.yml
sprint:
  duration: "2-weeks"
  start-date: "auto"
  capacity:
    team-size: 5
    availability: 0.8
planning:
  velocity-source: "linear"
  priority-weight: 0.6
  dependency-weight: 0.3
  balance-weight: 0.1
constraints:
  max-wip: 3
  carryover-limit: 5

Example invocation:

Copy
/sprint-planning-fast --team engineering --sprint-start 2026-03-16 --capacity 0.8

Example output:

Sprint Plan: Mar 16-29, 2026
==============================
Team: Engineering (5 members)
Availability: 80% (accounting for meetings, support)
Historical velocity: 34 pts/sprint (avg last 3)
Planned capacity: 34 story points

Priority backlog (selected):
  1. ENG-301: Fix auth token refresh (Critical, 5 pts) -> Alice
  2. ENG-298: Implement caching layer (High, 8 pts) -> Bob
  3. ENG-305: User profile editing (High, 5 pts) -> Carol
  4. ENG-310: API rate limiting (Medium, 5 pts) -> Dave
  5. ENG-312: Dashboard performance (Medium, 3 pts) -> Eve
  6. ENG-315: Email notification system (Medium, 5 pts) -> Alice
  7. ENG-318: Test coverage expansion (Low, 3 pts) -> Carol

Total planned: 34 story points (100% of capacity)

Dependencies:
  ENG-298 blocks ENG-312 (caching needed before dashboard optimization)
  ENG-301 should complete in week 1 (blocks integration testing)

Workload balance:
  Alice: 10 pts | Bob: 8 pts | Carol: 8 pts | Dave: 5 pts | Eve: 3 pts

Risks:
  - ENG-298 has external dependency on Redis setup
  - ENG-315 scope may expand based on email provider API limitations

Stretch goals (if capacity allows):
  ENG-320: Documentation update (2 pts)
  ENG-322: Minor UI polish (1 pt)

Core Concepts

Concept	Purpose	Details
Capacity Calculation	Determine available effort	Multiplies team size by sprint duration and availability factor to produce total available story points
Velocity Calibration	Set realistic commitment	Uses historical velocity averaged over recent sprints to set an achievable target that avoids over-commitment
Priority-Based Selection	Choose highest-impact work	Selects backlog items based on priority score, dependency constraints, and strategic alignment
Workload Balancing	Distribute work fairly	Assigns tasks to team members considering their expertise, availability, and current workload to prevent bottlenecks
Dependency Sequencing	Order tasks correctly	Identifies blocking relationships between tasks and sequences the sprint plan so that prerequisite tasks complete before dependent ones begin

Architecture: Sprint Planning
================================

+-------------------+     +---------------------+     +------------------+
| Backlog Analyzer  | --> | Capacity Calculator | --> | Priority Ranker  |
| (fetch + score)   |     | (team + velocity)   |     | (weighted sort)  |
+-------------------+     +---------------------+     +------------------+
                                                             |
                          +----------------------------------+
                          v
              +---------------------+     +-------------------+
              | Dependency Resolver | --> | Plan Generator    |
              | (task sequencing)   |     | (assignments)     |
              +---------------------+     +-------------------+

Configuration

Parameter	Type	Default	Description
team	string	required	Team identifier for fetching backlog items and team member availability
sprint-start	string	"auto"	Sprint start date, auto-detected from the team's sprint schedule if available
capacity	number	0.8	Availability factor between 0 and 1, accounting for meetings, support duties, and other non-development time
velocity-sprints	number	3	Number of recent sprints to average for velocity calculation
include-stretch	boolean	true	Include stretch goal recommendations beyond the core sprint commitment

Best Practices

1. Plan to eighty percent of historical velocity. Teams rarely operate at full capacity due to meetings, support interruptions, code reviews, and unexpected issues. Planning to eighty percent of your average velocity creates a realistic commitment that accounts for these overhead activities without requiring heroic effort.

2. Resolve dependencies early in the sprint. Schedule tasks that block other work items in the first half of the sprint so that dependent tasks can proceed on time. Leaving blocking tasks until the second week compresses the timeline for everything that depends on them, increasing the risk of carryover.

3. Balance workload considering expertise, not just capacity. Assigning tasks purely based on available capacity ignores the productivity differences between someone experienced with a module and someone encountering it for the first time. Factor in expertise when balancing assignments to produce realistic timelines.

4. Include stretch goals to handle early completion. When the team completes planned work ahead of schedule, having pre-identified stretch goals prevents idle time and keeps momentum. Keep stretch goals small and independent so they can be picked up without disrupting the main sprint plan.

5. Review the plan as a team before committing. The generated plan is a data-informed starting point, not a dictate. Present it during the sprint planning meeting for team discussion, adjustment, and consensus. Team buy-in on the commitment is essential for sprint success.

Common Issues

Velocity calculation skewed by outlier sprints. A single exceptionally productive or unproductive sprint can distort the average. Use median velocity or exclude outliers from the calculation to produce a more stable baseline that represents typical team performance.

Dependency analysis misses implicit dependencies. The planner identifies explicit blocking relationships but cannot detect implicit dependencies like shared database tables, API contracts, or design system components. Discuss potential implicit dependencies during the planning meeting to catch constraints the automated analysis misses.

Workload balance does not account for individual leave. The capacity calculator uses a team-wide availability factor but does not automatically account for individual vacation or sick days. Update individual team member availability before running the planner to ensure assignments reflect actual per-person capacity.