agentsclimarketplace

Sm capacity planning

Skill abrahamFerga/scrum-skills/skills/sm-capacity-planning

A vendor-agnostic library of AI agent skills built around the Scrum framework. Works with Claude Code, Cursor, GitHub Copilot, and any agentskills.io-compatible agent.

Install
npx -y skills add abrahamFerga/scrum-skills --skill sm-capacity-planning

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

  • 1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

Calculates team capacity for the upcoming Sprint by accounting for team size, Sprint length, planned time off, ceremony overhead, and individual focus factors. Outputs total developer-days available and a recommended story point commitment range. Use when a Scrum Master or team says things like "plan our capacity", "how many points can we commit to", "capacity for next sprint", "how much can we take on", or "account for holidays in the sprint". Do not use for sprint planning facilitation — use sprint-planning for that. Do not use for velocity analysis — use sm-velocity-review for that.

The file declares its own license as MIT. That is the author’s claim about this one file, and it is not the same thing as the license GitHub reports for the repository, which is listed with the other numbers below.

SKILL.md

6.5 KB, as published. Nobody here has run it

Sprint Capacity Planning

Purpose

Committing more than the team can actually deliver erodes trust, demoralises Developers, and makes velocity data meaningless. Committing too little wastes Sprint potential and frustrates the Product Owner. This skill does the arithmetic so the team can make an honest commitment.


Tool detection

  1. Check for active mcp__azure-devops__* tools → $PM_TOOL = ado
  2. Check for active mcp__jira__* tools → $PM_TOOL = jira
  3. If neither → $PM_TOOL = manual

Step 1 — Get Sprint parameters

Collect or detect the following:

Sprint dates

  • ADO: use work_list_team_iterations or work_list_iterations to find the next iteration and its start/end dates
  • Jira: use the sprint listing tool to find the upcoming sprint
  • Manual: ask "What are the start and end dates for the next Sprint?"

Calculate $WORKING_DAYS — the number of working days between start and end (exclude weekends by default; ask about public holidays in the team's locale).

Focus factor The percentage of working time a developer realistically spends on sprint work (excluding email, meetings outside Scrum, interruptions). Default: 70%. Ask if the team has a known different value.


Step 2 — Get team members

  • ADO: use work_get_team_capacity or work_get_iteration_capacities for the upcoming iteration; read each team member and their planned days off
  • Jira: use the team/member listing tool or ask manually
  • Manual: ask "Who is on the team this Sprint? List each person."

For each team member, ask (or read from the tool):

  • Days off during the Sprint (vacation, sick, training, public holidays)
  • Reduced availability (part-time, shared with another team, on-call rotation)

Step 3 — Calculate capacity

For each team member:

Available days = $WORKING_DAYS − days_off − reduced_availability_days
Focus hours = available_days × hours_per_day × focus_factor

Default: hours_per_day = 8, focus_factor = 0.70

Ceremony overhead — subtract the time the team spends in Scrum ceremonies:

CeremonyTypical duration
Sprint Planning2–4 hours (scale with Sprint length)
Daily Scrums15 min × working days
Sprint Review1–2 hours
Retrospective1–2 hours

Subtract ceremony hours from total focus hours to get net development hours per person.

Team total:

Total developer-hours = sum of net development hours across all team members
Total developer-days  = total developer-hours ÷ hours_per_day

Step 4 — Derive the story point range

Use the team's recent velocity to convert developer-days into story points.

Ask: "What is the team's average velocity over the last 3 Sprints?" (or fetch from sm-velocity-review if available).

Reference velocity = average story points completed per Sprint
Reference capacity = average developer-days in those Sprints

Points per developer-day = reference_velocity ÷ reference_capacity

Recommended commitment = total_developer_days × points_per_developer_day

Present as a range: recommended × 0.85 to recommended × 1.00 — the lower end accounts for uncertainty; the upper end is the ceiling.

If velocity data is not available, skip the point conversion and output developer-days only. Note that the team should track velocity for 2–3 Sprints before committing to point-based planning.


Step 5 — Present the capacity summary

Sprint Capacity — [SPRINT NAME] — [DATE RANGE]

Team: [N] developers
Working days: [N]
Focus factor: [X]%

┌─────────────────────┬───────────┬──────────┬──────────────┐
│ Developer           │ Days off  │ Net days │ Net hours    │
├─────────────────────┼───────────┼──────────┼──────────────┤
│ [Name]              │ [N]       │ [N]      │ [N]          │
│ [Name]              │ [N]       │ [N]      │ [N]          │
│ [Name]              │ [N]       │ [N]      │ [N]          │
└─────────────────────┴───────────┴──────────┴──────────────┘

Ceremony overhead: [N] hours
Total team capacity: [N] developer-days / [N] hours

Recommended commitment: [N–N] story points
(based on [N]-point average velocity over last [N] Sprints)

⚠ Flags:
  - [Any individual with < 50% availability — flag for PO awareness]
  - [Any Sprint significantly shorter than normal due to holidays]

Step 6 — Offer to save to ADO

Ask: "Should I save this capacity plan to ADO for the team's iteration?"

If yes, use work_update_team_capacity or equivalent to record each team member's days off and capacity in the iteration. This feeds burn-down charts automatically.


Guardrails

  • Never use 100% capacity as the commitment ceiling — humans are not machines and Scrum accounts for uncertainty.
  • Never assume every team member works the same hours — ask about part-time, shared, or on-call arrangements.
  • If a team member has more than 40% of the Sprint as days off, flag it to the Product Owner — the committed scope may need to shrink.
  • Capacity is an input to Sprint Planning, not the Sprint Goal. The team commits to the Sprint Goal; capacity just bounds what is achievable.

Keep looking

Skills are one crate of 328,083. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.