How to Facilitate Sprint Planning with Capacity Estimation and Risk Identification in PM Skills

The PM Skills repository provides a deterministic, five-step sprint planning workflow that automatically estimates team capacity with a 15-20% safety buffer, maps dependencies, and identifies risks with mitigation strategies through the sprint-plan skill.

The phuryn/pm-skills open-source project treats sprint planning as a first-class skill that transforms chaotic backlog grooming into a structured, repeatable process. When you need to facilitate sprint planning with capacity estimation and risk identification, the repository offers a declarative markdown-based workflow that separates process logic from UI implementation. This architecture allows the same planning logic to run via CLI commands, chatbots, CI pipelines, or IDE extensions without code duplication.

Understanding the Sprint-Plan Skill Architecture

The sprint planning capability resides in the sprint-plan skill defined in pm-execution/skills/sprint-plan/SKILL.md (lines 3-4). This file uses structured markdown headings to describe a deterministic workflow rather than imperative code, making the process human-readable and machine-parseable simultaneously.

The /sprint command in pm-execution/commands/sprint.md (lines 23-31) serves as the UI entry point. When a user invokes /sprint plan, the command routes the request to the skill engine, which injects context data (team availability, historic velocity, backlog items) into the skill template and returns a rendered markdown plan.

The Five-Step Sprint Planning Workflow

The skill enforces a rigorous sequence that ensures nothing is overlooked during planning sessions.

Estimate Team Capacity

The workflow begins by collecting team size, availability constraints (PTO, meetings, on-call rotations), and historic velocity from the provided context (lines 18-22 in SKILL.md). The system automatically applies a 15-20% safety buffer to protect against unplanned work and emergent tasks. The final capacity figure is expressed in story points or ideal hours, depending on your team's tracking methodology.

Review and Select Stories

Next, the skill pulls the highest-priority items from the backlog and validates each against the Definition of Ready (lines 24-28). Stories are selected sequentially until the accumulated estimate reaches the calculated capacity limit. This prevents the common anti-pattern of over-committing based on optimistic assumptions.

Map Dependencies

The workflow detects intra-team dependencies (stories blocking other stories) and external dependencies (third-party APIs, vendor integrations, other teams). It orders the stories accordingly to highlight the critical path (lines 30-35), ensuring the team understands which items must start first to avoid cascading delays.

Identify Risks and Mitigations

Before finalizing the plan, the skill flags high-uncertainty stories, external blockers, and knowledge-concentration risks (lines 36-40). For each identified risk, the template prompts for mitigation strategies—for example, scheduling vendor syncs for third-party dependencies or conducting early design walkthroughs for complex UI work.

Generate the Sprint Plan Summary

Finally, the skill emits a ready-to-use markdown template containing the sprint goal, duration, capacity breakdown, committed stories, and identified risks (lines 44-57). This output serves as both a team commitment document and a stakeholder communication artifact.

Invoking the Sprint-Plan Skill

You can trigger the sprint planning process through multiple interfaces depending on your automation needs.

Command Line Interface

Invoke the plan mode directly from your terminal or chat interface:

/sprint plan 2-week sprint, 4 engineers, focus on checkout improvements

The command parser extracts the sprint duration, team size, and thematic focus, then delegates execution to the sprint-plan skill.

Sample Output Structure

The skill generates a structured markdown plan similar to this:

## Sprint Plan: Checkout Improvement Sprint

**Duration**: 2026-07-01 – 2026-07-14
**Sprint Goal**: Reduce checkout friction by delivering "guest checkout" and "saved card" features
**Team Capacity**: 120 story points
**Committed Stories**: 95 story points across 8 stories
**Buffer**: 25 story points (20%)

### Stories

1. Guest Checkout — 13 pts — Alice — —  
2. Saved Card — 21 pts — Bob — depends on Guest Checkout —  
3. Payment UI Refresh — 8 pts — Carol — —  

### Risks

- Guest Checkout: UI complexity → Conduct early design walkthrough  
- Saved Card: External payment gateway integration → Schedule joint sync with vendor  

Programmatic Integration

For automated tooling or CI pipelines, invoke the skill programmatically:

from pm_skills import run_skill

# Prepare context with team data and backlog

context = {
    "team_members": ["Alice", "Bob", "Carol", "Dave"],
    "availability": {"Alice": 0.8, "Bob": 0.9, "Carol": 0.75, "Dave": 0.85},
    "velocity": [28, 30, 32],  # Last 3 sprints

    "backlog": [
        {"id": "CARD-101", "title": "Guest Checkout", "points": 13, "priority": 1},
        {"id": "CARD-102", "title": "Saved Card", "points": 21, "priority": 2}
    ]
}

plan_md = run_skill("sprint-plan", context)
print(plan_md)  # Renders the markdown plan

The run_skill helper loads the SKILL.md file, injects your context, and returns the rendered markdown without requiring you to parse the logic manually.

Key Files and Implementation Details

Understanding the source layout helps when customizing the workflow:

• pm-execution/skills/sprint-plan/SKILL.md – Contains the core workflow definition, capacity calculation rules, and risk identification prompts (lines 3-57).
• pm-execution/commands/sprint.md – Defines the user-facing /sprint command and its routing logic (lines 23-31).
• pm-execution/README.md – Provides an overview of execution-related skills and integration patterns (lines 15-31).
• README.md – Catalogs all available skills including sprint planning capabilities (lines 225-235).

The declarative architecture means you can modify planning parameters—such as adjusting the safety buffer percentage or adding new risk categories—by editing the markdown headers in SKILL.md without touching application code.

Summary

• The sprint-plan skill in pm-execution/skills/sprint-plan/SKILL.md provides a deterministic five-step workflow for structured sprint planning.
• Capacity estimation automatically applies a 15-20% buffer to historic velocity and availability data to prevent over-commitment.
• Risk identification occurs as a mandatory step before plan finalization, ensuring mitigations are documented for external dependencies and high-uncertainty stories.
• Declarative markdown architecture allows the same planning logic to run across CLI, chatbots, and CI pipelines via the run_skill helper.
• Output templates generate immediate, shareable sprint plans with capacity breakdowns, committed stories, and risk registers.

Frequently Asked Questions

How does the PM Skills sprint planning tool calculate team capacity?

The tool calculates capacity by multiplying team size by available working days, then adjusting for individual availability percentages (accounting for PTO, meetings, and on-call duties). It applies your historic velocity as a ceiling and automatically deducts a 15-20% safety buffer to create protected capacity for emergent work and technical debt.

Can I customize the risk categories in the sprint planning workflow?

Yes. Because the workflow is defined in declarative markdown at pm-execution/skills/sprint-plan/SKILL.md (lines 36-40), you can modify the risk identification section by editing the structured headings. Add new subsections for specific risk types (such as "security review delays" or "third-party certification dependencies") and the run_skill engine will include them in generated plans.

What is the difference between the /sprint command and the sprint-plan skill?

The /sprint command in pm-execution/commands/sprint.md provides the user interface and argument parsing, while the sprint-plan skill contains the actual business logic and workflow steps. This separation follows the Command-Query Responsibility Segregation pattern: the command handles "how the user asks" while the skill handles "what gets done," enabling the same skill to be reused across Slack, Discord, VS Code extensions, or GitHub Actions without rewriting the planning logic.

Does the sprint planning output integrate with Jira or other issue trackers?

The current implementation generates markdown output that can be parsed or rendered directly. While the core pm-skills repository focuses on the planning workflow itself, the markdown structure (defined in lines 44-57 of SKILL.md) uses standard formatting that can be processed by automation scripts to create Jira sprints, update Confluence pages, or post to Slack channels via the run_skill Python helper.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}