# How Sprint Planning Mode Works in PM Skills: A Complete Technical Guide

> Discover how Sprint Planning mode in PM Skills works. This guide details the six-step workflow for capacity, backlog, dependencies, risks, and sprint plan generation.

- Repository: [Pawel Huryn/pm-skills](https://github.com/phuryn/pm-skills)
- Tags: technical-guide
- Published: 2026-06-10

---

**Sprint Planning mode executes a six-step workflow that calculates team capacity, selects prioritized backlog stories, maps dependencies, identifies risks, and emits a structured markdown sprint plan.**

The `phuryn/pm-skills` repository provides a command-driven toolkit for product management workflows. Sprint Planning mode is one of three lifecycle phases available through the `/sprint` command, orchestrated by the `sprint-plan` skill to transform unstructured backlog data into actionable sprint plans.

## Architecture of Sprint Planning Mode

The system consists of two primary components that handle command parsing and workflow execution.

### The /sprint Command Handler

Located in [[`pm-execution/commands/sprint.md`](https://github.com/phuryn/pm-skills/blob/main/pm-execution/commands/sprint.md)](https://github.com/phuryn/pm-skills/blob/main/pm-execution/commands/sprint.md), the command handler recognizes three lifecycle phases: `plan`, `retro`, and `release-notes`. When invoked with the `plan` sub-command, it collects sprint context and forwards execution to the `sprint-plan` skill.

### The sprint-plan Skill

The core workflow logic resides in [[`pm-execution/skills/sprint-plan/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-execution/skills/sprint-plan/SKILL.md)](https://github.com/phuryn/pm-skills/blob/main/pm-execution/skills/sprint-plan/SKILL.md). This skill implements a deterministic six-step process that optionally reads user-supplied files—such as backlog CSVs, velocity data, or roster spreadsheets—before executing the planning logic.

## The Six-Step Sprint Planning Workflow

When you trigger Sprint Planning mode, the `sprint-plan` skill executes the following sequence defined in the source file:

1. **Capacity Calculation** – Combines team member availability with historic velocity from the last three sprints and applies a 15–20% buffer to account for uncertainty (lines 18–22).
2. **Story Selection** – Pulls highest-priority items from the backlog, validates Definition of Ready criteria, and commits stories until capacity limits are reached (lines 24–29).
3. **Dependency Mapping** – Identifies intra-team and external dependencies, annotating critical paths that could block execution (lines 30–34).
4. **Risk Identification** – Flags high-uncertainty stories, external blockers, and knowledge concentration issues, proposing specific mitigations for each (lines 36–40).
5. **Summary Generation** – Assembles a markdown document using the template defined in lines 44–57, including capacity tables, story lists, and risk registers.
6. **Sprint Goal Definition** – Prompts the user to craft a concise sprint goal that aligns with the selected work (line 59).

## Inputs and Outputs

### Input Data Sources

According to line 14 of [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md), the skill reads optional user-supplied files first to populate the planning context:

- **Backlog CSVs** containing `priority` and `estimate` columns
- **Velocity data** from previous sprints
- **Roster spreadsheets** detailing team availability
- **Prior sprint reports** for historical analysis

### Output Markdown Structure

The generated sprint plan follows the strict markdown template defined in lines 44–57 of the skill file, including:

```markdown

## Sprint Plan: [Sprint Name]

**Duration**: YYYY-MM-DD → YYYY-MM-DD  
**Sprint Goal**: [Concise objective]

### Capacity

| Member | Available Days | Points/Hours | Notes |
|--------|----------------|--------------|-------|

### Committed Stories

| Story | Estimate | Assignee | Dependencies |

### Risk Register

| Risk | Impact | Mitigation |

```

## Practical Usage Examples

### Basic Command Invocation

Trigger Sprint Planning mode with natural language context:

```text
/sprint plan 2-week sprint, 5 engineers, focus on checkout improvements

```

The command parser recognizes the `plan` sub-command and initializes the workflow with the provided parameters.

### Attaching Backlog Data

Supply a CSV file for the skill to process before execution:

```text
/sprint plan
<attach file=backlog.csv>

```

The skill reads `backlog.csv` first (line 14) and uses its `priority` and `estimate` columns when selecting stories.

### Sample Generated Output

The final markdown output resembles:

```markdown
Sprint Goal: Enable users to complete checkout in under 2 minutes
Duration: 2 weeks
Team Capacity: 120 story points
Committed Stories: 95 story points across 8 stories
Buffer: 25 points

Stories:
1. Checkout page redesign — 13 — Alice — none
2. Payment gateway integration — 21 — Bob — depends on #1

Risks:
- Payment gateway API rate-limit → request higher quota early
- Design hand-off not final → schedule extra review

```

## Summary

- **Sprint Planning mode** is activated via `/sprint plan` and managed by the `sprint-plan` skill in the `phuryn/pm-skills` repository.
- The workflow follows six deterministic steps: capacity estimation, story selection, dependency mapping, risk analysis, document generation, and goal definition.
- **Key files**: [[`pm-execution/commands/sprint.md`](https://github.com/phuryn/pm-skills/blob/main/pm-execution/commands/sprint.md)](https://github.com/phuryn/pm-skills/blob/main/pm-execution/commands/sprint.md) handles command parsing, while [[`pm-execution/skills/sprint-plan/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-execution/skills/sprint-plan/SKILL.md)](https://github.com/phuryn/pm-skills/blob/main/pm-execution/skills/sprint-plan/SKILL.md) contains the workflow logic and templates.
- The system calculates capacity using a 15–20% buffer based on the last three sprints' velocity data.
- Output is a structured markdown document ready for import into project management tools or version control.

## Frequently Asked Questions

### How do I activate Sprint Planning mode in PM Skills?

Invoke the mode by typing `/sprint plan` followed by your sprint parameters. The command handler in [`pm-execution/commands/sprint.md`](https://github.com/phuryn/pm-skills/blob/main/pm-execution/commands/sprint.md) parses your input and routes execution to the `sprint-plan` skill, which immediately begins the six-step workflow.

### What data files does Sprint Planning mode accept?

The skill accepts optional CSV and spreadsheet files containing backlog items, velocity history, and team rosters. According to line 14 of [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md), the system reads these files first to populate the planning context before prompting for additional details.

### How does the capacity calculation work?

The skill combines current team availability with historical velocity data from the previous three sprints, then applies a 15–20% buffer to account for uncertainty. This calculation occurs in lines 18–22 of the skill definition, ensuring realistic commitment targets that account for typical variability.

### Can I customize the sprint plan output template?

The markdown output follows the template defined in lines 44–57 of [`pm-execution/skills/sprint-plan/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-execution/skills/sprint-plan/SKILL.md). While the structure is standardized, you can edit the generated markdown after the skill produces it, or modify the skill file directly to adjust sections like capacity tables or risk registers.