AgentStack
Browse Sign in
Browse Why AgentStack Sell Docs
Sign in
SKILL verified MIT Self-run

Sm Capacity Planning

skill-abrahamferga-scrum-skills-sm-capacity-planning · by abrahamFerga

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 t…

No reviews yet
0 installs
39 views
0.0% view→install

Install

$ agentstack add skill-abrahamferga-scrum-skills-sm-capacity-planning

✓ scanned · ✓ verified, works with Claude Code, Cursor, and more.

Security review

✓ Passed

No issues found. Passed automated security review. · v0.1.0 How review works →

  • Prompt-injection patterns
  • Secret / credential exfiltration
  • Dangerous shell & filesystem operations
  • Untrusted network calls
  • Known-malicious package signatures

What it can access

  • Network access No
  • Filesystem access No
  • Shell / process execution No
  • Environment & secrets No
  • Dynamic code execution No

From automated source analysis of v0.1.0. “Used” means the capability is present in the source — more access means more to trust, not that it’s unsafe.

View the full security report →

Verified badge

Passed review? Show it. Paste this badge into your README, it links to the public security report.

AgentStack Verified badge Links to your public security report.
[![AgentStack Verified](https://agentstack.voostack.com/badges/verified.svg)](https://agentstack.voostack.com/security/report/skill-abrahamferga-scrum-skills-sm-capacity-planning)

Reliability & compatibility

Security review passed
0 installs to date
no reviews yet
4mo ago

Declared compatibility

Claude CodeClaude Desktop

Compatibility is declared by the source manifest. End-to-end runtime verification is coming, see below.

Preview Execution monitoring

We're building live execution health for every listing: tool-call success rate, median latency, uptime, and last-checked timestamps, measured, not self-reported. It isn't live yet, so we don't show numbers we can't stand behind.

How agent discovery & health will work →
Are you the author of Sm Capacity Planning? Claim this listing to set pricing, connect Stripe payouts, and keep 70% of every sale.
Sign up to claim

About

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:

| Ceremony | Typical duration | |---|---| | Sprint Planning | 2–4 hours (scale with Sprint length) | | Daily Scrums | 15 min × working days | | Sprint Review | 1–2 hours | | Retrospective | 1–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.

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

Install and usage instructions live in the source repository linked above.

Reviews

No reviews yet, be the first.

Versions

  • v0.1.0 Imported from the upstream source.