fte-capacity-sizing
GitHub基于70% AI/30%人工模型，估算机构项目所需FTE、角色组合及团队规模。通过脚本量化交付物工作量与财务可行性，辅助制定人员配置计划、检查容量缺口及验证团队合理性。
Trigger Scenarios
Install
npx skills add NeverSight/learn-skills.dev --skill fte-capacity-sizing -g -y
SKILL.md
Frontmatter
{
"name": "fte-capacity-sizing",
"description": "Estimates the FTE capacity, role mix, seniority, utilization, and delivery load required for agency scopes, campaigns, CRM programs, media operations, or retained services. Applies a 70\/30 AI-to-human operating model where 70% of task volume is handled by AI agents and 30% requires human judgment. Use when asked to size a team, build a staffing plan, estimate headcount, design a pod structure, check capacity, or determine if a fee can support a team. Also trigger when someone says \"how many people do we need?\", \"can we staff this?\", \"is this team right-sized?\", \"what's the capacity gap?\", \"build me a resource plan\", or when the agency-request-intake-router or scope-audit routes here due to capacity concerns. Even casual phrasing like \"do we have enough people?\", \"who works on this?\", or \"is the team big enough?\" should activate this skill."
}
FTE Capacity Sizing
Translate any agency scope — SOW, retainer, campaign brief, or informal request — into a concrete staffing model with role-by-role FTE allocation, utilization analysis, seniority validation, and financial viability assessment against the proposed fee.
The 70/30 Operating Model
This skill operates on a foundational principle: 70% of agency task volume is handled by AI agents (Claude skills, MCP flows, automated pipelines) and 30% requires irreducible human judgment, creativity, and relationships. This is not aspirational — it is the operating assumption built into every calculation.
What this means in practice:
- A deliverable requiring 8 gross hours doesn't need 8 human hours — it needs 8 × (1 - AI rate) human hours
- A monthly report with 85% AI automation needs only 1.2 human hours (AI generates the report, a human reviews and presents)
- A creative concept with 20% AI rate still needs 12.8 human hours of 16 total (creativity remains human-led)
- The FTE count reflects the human core, not the full task volume
- Read
references/hour_benchmarks.md→ section "The 70/30 Operating Model" for the full rationale and empirical basis
Quick Reference
| Resource | Purpose | Usage |
|---|---|---|
scripts/capacity_calculator.py |
Core calculation engine — takes deliverables JSON, applies AI rates, calculates FTE, models utilization, assesses financials | python capacity_calculator.py --input deliverables.json --fee 25000 --client "AcmeAuto MX" --output capacity.json |
references/hour_benchmarks.md |
Industry hour benchmarks per deliverable type, AI automation rates, the 70/30 model rationale, common staffing patterns | Read for effort estimation when building the deliverables input |
references/role_catalog.md |
Role definitions, AI vs. human responsibility matrix, seniority minimums, pod configurations | Read when determining discipline assignment and seniority requirements |
How to Use the Script
When the user provides scope information, follow this workflow:
- Extract deliverables from the scope document or conversation
- Build a deliverables JSON array using hour benchmarks from
references/hour_benchmarks.md - Run the calculator to get quantitative results
- Layer qualitative analysis — the script provides numbers, you provide judgment on team dynamics, client complexity, and market context
import sys
sys.path.insert(0, "<skill-path>/scripts")
from capacity_calculator import CapacityCalculator
deliverables = [
{"name": "Social posts (12/mo)", "quantity_per_month": 12, "hours_per_unit": 1.5,
"task_type": "copy_variations", "discipline": "creative", "seniority": "mid"},
{"name": "Monthly report", "quantity_per_month": 1, "hours_per_unit": 8,
"task_type": "reporting", "discipline": "data", "seniority": "mid"},
{"name": "Weekly optimization", "quantity_per_month": 4, "hours_per_unit": 3,
"task_type": "bid_optimization", "discipline": "media", "seniority": "mid"},
{"name": "Client status call", "quantity_per_month": 4, "hours_per_unit": 2,
"task_type": "client_relationship", "discipline": "account", "seniority": "mid"},
]
calc = CapacityCalculator(deliverables, monthly_fee=15000, client_name="FreshBrew")
result = calc.calculate()
# result.total_fte_required, result.ai_pct, result.margin_pct, result.roles, etc.
Calibration note: The script uses fixed benchmark hours and AI rates. Real-world effort varies by client complexity, platform maturity, and team experience. Use the script's output as a starting point and adjust based on context. If the user provides actual time-tracking data, use those numbers instead of benchmarks.
Trigger Conditions
Activate this skill when:
- The user needs to size a team for a scope, retainer, or campaign
- The user asks how many FTEs, what roles, or what seniority is needed
- The
scope-auditflags capacity risk and routes here - The
agency-request-intake-routeridentifies a capacity question - The user wants to check if a fee can support the required staffing
- The user is building a proposal and needs the team section
- The user asks about utilization or workload balance
Sizing Process
Work through all seven steps. Each builds on the previous one.
Step 1 — Parse Scope into Deliverables
Read the scope and decompose it into individual deliverables. For each deliverable, capture:
- Name: What it is (e.g., "12 Instagram posts per month")
- Quantity per month: How many units per month
- Hours per unit: Effort per unit (use
references/hour_benchmarks.mdif not provided) - Task type: Classification for AI rate lookup (e.g.,
reporting,bid_optimization,creative_concept) - Discipline: Which team owns it (account, strategy, creative, media, crm, data, pm, production, tech)
- Seniority: Minimum seniority required (junior, mid, senior, director)
If the scope doesn't specify hours, use the benchmarks. If it doesn't specify disciplines, infer from deliverable type. If seniority isn't stated, use the minimums from references/role_catalog.md.
Step 2 — Apply the 70/30 AI Split
For each deliverable, apply the AI automation rate to calculate net human hours:
Net human hours = Gross hours × (1 - AI automation rate)
AI hours = Gross hours × AI automation rate
The AI rate depends on the task type. See references/hour_benchmarks.md for the full rate table. If a task type isn't listed, estimate based on the AI Rate Guide matrix:
- Data-driven and repetitive → 70-90%
- Structured with some judgment → 40-65%
- Strategy and creative → 20-35%
- Relationships and crisis → 5-15%
Step 3 — Aggregate by Role
Group deliverables by discipline. For each role, sum:
- Total gross hours per month
- Total human hours per month (after AI reduction)
- Total AI hours per month
Step 4 — Calculate FTE per Role
Convert human hours to FTE using utilization-adjusted capacity:
Available hours = 168 hrs/month × utilization target
FTE required = Human hours / Available hours
Utilization targets by seniority:
- Junior: 80% → 134.4 available hrs
- Mid: 75% → 126.0 available hrs
- Senior: 65% → 109.2 available hrs
- Director: 50% → 84.0 available hrs
Step 5 — Assess Utilization Risk
Flag roles where:
- Utilization > 95%: Overstretched — burnout risk, no buffer for ad hoc work
- Utilization > 85%: At capacity — limited flexibility
- FTE < 0.15: Fragmented — too small to justify dedicated headcount, consider shared or AI-first
Step 6 — Validate Seniority
Check each deliverable against minimum seniority requirements. Flag mismatches where a junior is assigned strategy work or a mid-level person handles executive presentations. See references/role_catalog.md → "Seniority Minimums by Task" for the full matrix.
Step 7 — Financial Viability
If a monthly fee is provided, calculate:
Total monthly cost = Σ (FTE per role × monthly cost per FTE at that seniority)
Margin = (Fee - Cost) / Fee × 100
Use cost benchmarks from references/hour_benchmarks.md → "Role Cost Benchmarks."
Issue a verdict:
- Viable: Margin ≥ 30% (target)
- Tight but viable: Margin 15-30%
- Underfunded: Margin 0-15%
- Non-viable: Negative margin
Output Format
Produce the capacity model in TWO forms: first as an inline visual artifact (rendered in chat via the Visualizer), then as a structured markdown report below it.
Visual Artifact (Primary)
Render the capacity model as an inline HTML widget using the Visualizer. The widget should display:
- A header bar color-coded by verdict: green (Viable), amber (Tight), orange (Underfunded), red (Non-viable)
- A top metrics row with 4 cards: Total FTE, AI/Human split (as "70/30" style ratio), Monthly cost, Margin %
- A role allocation table — one row per role showing: discipline, seniority, gross hrs, human hrs, AI hrs, FTE, utilization %, status badge (OK/Overstretched/Fragmented)
- A stacked bar showing the AI vs. human hour breakdown visually (green for AI, blue for human)
- An alerts section listing utilization risks and seniority gaps with severity badges
- An action footer with
sendPrompt()buttons:- "Run margin simulation for [client] with this staffing model" → routes to
margin-simulation - "Generate scope change order to reduce deliverables" → routes to
change-order-generator - "Draft executive memo with team recommendation" → routes to
executive-growth-memo
- "Run margin simulation for [client] with this staffing model" → routes to
Use CSS variables for light/dark mode. Keep it compact — a staffing dashboard card, not a spreadsheet.
Markdown Report (Secondary)
After the visual artifact, produce the full capacity model as markdown:
## 👥 FTE CAPACITY MODEL — [Client / Project Name]
### Staffing summary
[2-3 sentences: total FTE, AI/human split, verdict, key risk]
### The 70/30 split
| Metric | Value |
|--------|-------|
| Total gross hours/month | [X] |
| AI-operated hours (70% target) | [X] ([Y]%) |
| Human hours (30% target) | [X] ([Y]%) |
| Total FTE required (human) | [X] |
### Role-by-role allocation
| Role | Seniority | Gross hrs | Human hrs | AI hrs | FTE | Utilization | Status |
|------|-----------|-----------|-----------|--------|-----|-------------|--------|
[One row per role]
### Utilization risk
[Table: role | issue | severity | recommendation]
### Seniority gaps
[If any: deliverable | assigned | minimum | recommendation]
### Financial viability
| Metric | Value |
|--------|-------|
| Monthly fee | $[X] |
| Monthly team cost | $[X] |
| Margin | [X]% |
| Verdict | [Viable / Tight / Underfunded / Non-viable] |
### Required vs. funded capacity
[If underfunded: which roles are the gap, what to cut or renegotiate]
### Recommendations
[Numbered list of specific actions]
When Information Is Incomplete
If the user provides only a partial scope or verbal summary:
- Use benchmark hours from
references/hour_benchmarks.mdfor estimation - Note assumptions explicitly (e.g., "Assumed 8 hrs/report based on industry benchmark")
- Mark uncertain fields with
⚠️ Estimated — [basis] - Recommend providing the full SOW or time-tracking data for a precise model
Examples
Example 1 — Small social retainer:
User: "We need to size a team for a social-only retainer: 12 posts/month on Instagram and TikTok, monthly report, weekly client call. Fee is $10,000/month."
→ 0.8 FTE total (0.3 Creative mid, 0.2 Account mid, 0.15 Data mid, 0.15 PM mid). AI handles 68% of hours. Margin: 42%. Verdict: Viable.
Example 2 — Underfunded full-service:
User: "Client wants full-service digital: media planning, creative production, CRM journeys, monthly reporting, QBRs. Fee: $18,000/month."
→ 2.1 FTE required across 6 disciplines. Cost: $22,400/month. Margin: -24%. Verdict: Non-viable. Recommendation: reduce scope or increase fee by $6,000+.
Example 3 — Capacity check:
User: "Our media team is already at 90% utilization. Can we take on this new $15K/month account that needs 3 campaigns per month?"
→ New account requires 0.4 FTE media. Current team at 90% → would push to 120%. Risk: Critical. Recommendation: hire 0.5 FTE media mid or redistribute existing workload with AI automation uplift.
Skill Chaining
This skill frequently connects to:
| Condition | Next skill |
|---|---|
| Fee can't support required team | margin-simulation to model alternatives |
| Scope needs reducing to fit budget | change-order-generator |
| Team recommendation needs leadership summary | executive-growth-memo |
| Staffing model is set, campaign ready to launch | campaign-launch-qa |
| Utilization is critical, need weekly monitoring | weekly-control-tower |
Version History
- e0220ca Current 2026-07-05 23:37
