/capacity-planner

name: capacity-planner
description: "Use when an ops leader (Director of CX, Head of Support, VP Ops, Head of BizOps, Head of IT ops, Head of Finance ops) is sizing ops capacity, building a headcount plan, modeling utilization risk, planning Q3 capacity or annual support capacity, or designing CS coverage — and needs Erlang-C queueing math, P90 demand sizing, shrinkage-adjusted FTE, manager-trigger thresholds, and a quarterly hiring sequence with ramp + attrition. Apply when sustained team utilization is above 80% or when the team is growing >50% in 12 months. Run before committing the headcount budget. This is NOT engineering capacity (see vpe-advisor for DORA + cycle time) and NOT strategic 3-year workforce planning (see chro-advisor)."
version: 2.8.0
author: claude-code-skills
license: MIT
tags: [bizops, capacity, headcount, utilization, queueing-theory, ops-planning, little-law, workforce]
compatible_tools: [claude-code, codex-cli, cursor, antigravity, opencode, gemini-cli]

capacity-planner

Sizing tool for **ops teams that handle queued work** — Support, CX, Customer Success, BizOps, IT ops, Finance ops. Built on Erlang-C queueing theory, Little's Law, and the operational-leadership canon (Fournier, Larson, Cleveland, Reinertsen). Deterministic, stdlib-only, no LLM calls.

Purpose

You are an ops leader sized 15 → 35 with no idea how the 35-person org will actually behave at peak load. Or you are at 88% utilization and SLA is starting to slip. Or you have a hiring budget approved and need to sequence it across four quarters without burning out the existing team. This skill answers those questions with arithmetic, not vibes.

It produces three artifacts:

1. **Capacity sizing** at 70/80/90% utilization against P50/P90/P99 demand, with P(SLA breach) at each point and a SAFE/WATCH/AT_RISK/CRITICAL risk band. 2. **Utilization health** at the per-member traffic-light level plus a team verdict (HEALTHY/SQUEEZED/OVERLOADED/UNBALANCED). 3. **12-month quarterly hiring plan** accounting for ramp curves, attrition, QoQ demand growth, and span-of-control manager triggers.

When to use

• **Annual ops capacity planning** (October-November for the following

fiscal year).

• **Quarterly re-sizing** if demand changed >15% or attrition spiked.
• **Pre-budget defense** — the math that justifies the headcount ask

to your CFO.

• **Diagnostic** when an ops team is missing SLA and you need to know

whether it's a sizing problem, a process problem, or a bottleneck problem.

• **M&A / new-segment launch** modeling — sizing a new team or

combined org.

Workflow

1. **Intake demand**. Pull P50/P90/P99 daily ticket/case volume from your work system (Zendesk, Intercom, JSM, ServiceNow, Salesforce). If you only have averages, stop and pull the distribution. Single- point demand estimates are the most expensive anti-pattern in ops. 2. **Model throughput**. Run `capacity_modeler.py` with your demand, AHT, SLA target, current FTE, and shrinkage. Use `--profile` for your function (support / cx / bizops / finance-ops / it-ops). Read the 80%-utilization row — that's your sizing point. 3. **Flag utilization risk**. Run `utilization_analyzer.py` against your current team's actual utilization data. Anyone >85% sustained is a throughput-collapse risk per Reinertsen. Spread >30 percentage points across team means UNBALANCED — fix that before hiring. 4. **Sequence hiring**. Run `hiring_sequencer.py` with current FTE, target EOY, ramp time, attrition, and growth. It will front-load hires (Q1 35%, Q4 15%), apply ramp curves, and trigger a manager hire when span of control crosses 7 ICs/manager. 5. **Walk the Forcing-question library** (see below). One question at a time. Do not skip ahead. Answers must be written down before you commit the plan.

Scripts

• `scripts/capacity_modeler.py` — Erlang-C sizing with shrinkage

adjustment and P50/P90/P99 breach probabilities. `--profile` for industry defaults.

• `scripts/utilization_analyzer.py` — per-member traffic-light +

team-level health verdict with variance detection.

• `scripts/hiring_sequencer.py` — 12-month quarterly plan with ramp,

attrition, growth, max-hires-per-quarter constraint, and manager-trigger logic.

All three accept `--input <path>` (JSON), `--output {markdown,json}`, `--sample` (built-in example), and `--help`. Stdlib only.

Quick example

# Emits an Erlang-C capacity model (required headcount + P50/P90/P99 breach probabilities) for the built-in example
cd business-operations/skills/capacity-planner && python3 scripts/capacity_modeler.py --sample

References

• `references/queueing_theory_canon.md` — Erlang, Little, Hopp &

Spearman, Reinertsen, Kingman, Cleveland, ITIL, Armony et al. (8 sources). The math.

• `references/ops_workforce_planning_canon.md` — Fournier, Larson,

Google SRE Workbook, Frei, Lawler, Bersin, Gartner, Grove (8 sources). The people factors.

• `references/capacity_anti_patterns.md` — 11 named anti-patterns

with cited sources, tool guards, and the meta-discipline that Lencioni + Goldratt + Christensen impose. (8+ named sources.)

Assets

• `assets/capacity_brief_template.md` — 20-minute fill-out template

with JSON skeletons for all three tools and an output checklist.

Assumptions

This skill assumes:

• Work is **queued** (tickets, cases, work items) — not project-style.

If your team's work isn't queued, this is the wrong skill.

• Demand has a **stationary-enough distribution** within a quarter.

Step-changes (new product launch, M&A, regulatory shift) require re-running mid-quarter.

• You have **at least 90 days of historical demand data** to compute

P50/P90/P99. If not, generate the distribution from your sales / user-base forecast first.

• Service is **single-class** within a queue. If you have hard

priority tiers (P1/P2/P3 with class-specific SLAs), model each as a separate queue and sum.

• **Ch