capacity-planning
Plan organizational capacity for construction projects. Forecast resource needs, identify capacity gaps, and support strategic planning for project pursuit and staffing.
Install / Use
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill capacity-planningInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
AutomationSupported Platforms
Our assessment of capacity-planning
capacity-planning scores 91/100 on our quality scale, 1105th of 2,771 Automation skills we index (top 40%).
Its SKILL.md is 20 KB long, well organised into 13 sections with 4 code examples: a thorough specification that gives an agent plenty to work with.
It has 333 GitHub stars, a meaningful sign that others use it.
Maintenance, license and trust
- The repository was last updated about 3 months ago, so capacity-planning is actively maintained.
- Our last check on 2026-11-20 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-07. Automated pattern scan on 2026-10-07. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
capacity-planning compared with similar skills
All 4 of these similar skills score higher than capacity-planning; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| capacity-planning (this skill)by datadrivenconstruction | 91 | 333 | 3mo ago | SKILL.md |
| Agent-Reachby Panniantong | 100 | 113.3k | 12d ago | CLAUDE.md |
| rufloby ruvnet | 100 | 82.1k | today | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 80.2k | today | CLAUDE.md |
| Claude-Code-Game-Studiosby Donchitos | 100 | 40.2k | 10d ago | CLAUDE.md |
Frequently asked questions
- How do I install capacity-planning?
- Run
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill capacity-planning. The install tabs above show the steps for each supported agent. - Which AI agents does capacity-planning work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is capacity-planning safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is capacity-planning still maintained?
- The repository was last updated about 3 months ago, so capacity-planning is actively maintained.
Skill content
View source on GitHubname: "capacity-planning" description: "Plan organizational capacity for construction projects. Forecast resource needs, identify capacity gaps, and support strategic planning for project pursuit and staffing." homepage: "https://datadrivenconstruction.io" metadata: {"openclaw": {"emoji": "🚀", "os": ["darwin", "linux", "win32"], "homepage": "https://datadrivenconstruction.io", "requires": {"bins": ["python3"]}}}
Capacity Planning
Overview
Strategic capacity planning for construction organizations. Forecast resource requirements based on project pipeline, identify capacity constraints, optimize staffing levels, and support go/no-go decisions on new project pursuits.
Capacity Planning Framework
┌─────────────────────────────────────────────────────────────────┐
│ CAPACITY PLANNING │
├─────────────────────────────────────────────────────────────────┤
│ │
│ DEMAND FORECAST CAPACITY ANALYSIS DECISIONS │
│ ─────────────── ───────────────── ───────── │
│ │
│ Current Projects → Available: Pursue new │
│ • Project A (Active) 👷 PM: 5 project? │
│ • Project B (Active) 👷 Supers: 12 ──────── │
│ • Project C (Starting) 📐 Engineers: 8 ✅ Capacity │
│ ⚠️ Stretch │
│ Pipeline: → Required: ❌ Decline │
│ • Bid D (60% win) 👷 PM: 7 │
│ • Bid E (40% win) 👷 Supers: 15 │
│ • Opportunity F 📐 Engineers: 10 │
│ │
│ GAP ANALYSIS: ACTIONS: │
│ • PM: -2 (deficit) • Hire 2 PMs │
│ • Supers: -3 (deficit) • Promote from within │
│ • Engineers: -2 (deficit) • Partner with firm │
│ │
└─────────────────────────────────────────────────────────────────┘
Technical Implementation
from dataclasses import dataclass, field
from typing import List, Dict, Optional, Tuple
from datetime import datetime, timedelta
from enum import Enum
import statistics
class ResourceRole(Enum):
PROJECT_MANAGER = "project_manager"
SUPERINTENDENT = "superintendent"
PROJECT_ENGINEER = "project_engineer"
ESTIMATOR = "estimator"
SCHEDULER = "scheduler"
SAFETY_MANAGER = "safety_manager"
QC_MANAGER = "qc_manager"
ADMIN = "admin"
class ProjectPhase(Enum):
PURSUIT = "pursuit"
PRECONSTRUCTION = "preconstruction"
CONSTRUCTION = "construction"
CLOSEOUT = "closeout"
class OpportunityStatus(Enum):
IDENTIFIED = "identified"
PURSUING = "pursuing"
BID_SUBMITTED = "bid_submitted"
NEGOTIATING = "negotiating"
WON = "won"
LOST = "lost"
@dataclass
class StaffMember:
id: str
name: str
role: ResourceRole
capacity: float = 1.0 # FTE
current_assignment: str = ""
availability_date: datetime = None
skills: List[str] = field(default_factory=list)
max_project_value: float = 0 # Max project size they can handle
@dataclass
class ProjectDemand:
project_id: str
project_name: str
value: float
phase: ProjectPhase
start_date: datetime
end_date: datetime
probability: float = 1.0 # 1.0 for active, <1 for pipeline
resource_needs: Dict[ResourceRole, float] = field(default_factory=dict)
@dataclass
class CapacityGap:
role: ResourceRole
period_start: datetime
period_end: datetime
demand: float
capacity: float
gap: float
severity: str
@dataclass
class CapacityForecast:
forecast_date: datetime
horizon_months: int
total_demand_fte: float
total_capacity_fte: float
utilization_pct: float
gaps: List[CapacityGap]
recommendations: List[str]
class CapacityPlanner:
"""Plan organizational capacity for construction projects."""
# Typical staffing ratios by project value
STAFFING_RATIOS = {
ResourceRole.PROJECT_MANAGER: 20000000, # 1 PM per $20M
ResourceRole.SUPERINTENDENT: 10000000, # 1 Super per $10M
ResourceRole.PROJECT_ENGINEER: 15000000, # 1 PE per $15M
ResourceRole.ESTIMATOR: 50000000, # 1 Estimator per $50M (pursuit)
ResourceRole.SCHEDULER: 30000000, # 1 Scheduler per $30M
ResourceRole.SAFETY_MANAGER: 25000000, # 1 Safety per $25M
}
# Phase factors (multiply by role ratio)
PHASE_FACTORS = {
ProjectPhase.PURSUIT: {"estimator": 1.5, "pm": 0.3},
ProjectPhase.PRECONSTRUCTION: {"pm": 0.7, "pe": 0.5, "scheduler": 0.5},
ProjectPhase.CONSTRUCTION: {"pm": 1.0, "super": 1.0, "pe": 1.0, "safety": 1.0},
ProjectPhase.CLOSEOUT: {"pm": 0.5, "pe": 0.3, "admin": 1.0}
}
def __init__(self, organization_name: str):
self.organization_name = organization_name
self.staff: Dict[str, StaffMember] = {}
self.projects: Dict[str, ProjectDemand] = {}
self.pipeline: Dict[str, ProjectDemand] = {}
def add_staff(self, id: str, name: str, role: ResourceRole,
capacity: float = 1.0, current_assignment: str = "",
availability_date: datetime = None,
max_project_value: float = 0) -> StaffMember:
"""Add staff member to capacity pool."""
member = StaffMember(
id=id,
name=name,
role=role,
capacity=capacity,
current_assignment=current_assignment,
availability_date=availability_date or datetime.now(),
max_project_value=max_project_value
)
self.staff[id] = member
return member
def add_active_project(self, id: str, name: str, value: float,
phase: ProjectPhase, start_date: datetime,
end_date: datetime) -> ProjectDemand:
"""Add active project to demand forecast."""
# Calculate resource needs based on value and phase
needs = self._calculate_resource_needs(value, phase)
project = ProjectDemand(
project_id=id,
project_name=name,
value=value,
phase=phase,
start_date=start_date,
end_date=end_date,
probability=1.0,
resource_needs=needs
)
self.projects[id] = project
return project
def add_pipeline_opportunity(self, id: str, name: str, value: float,
win_probability: float,
expected_start: datetime,
duration_months: int) -> ProjectDemand:
"""Add pipeline opportunity to demand forecast."""
needs = self._calculate_resource_needs(value, ProjectPhase.CONSTRUCTION)
opportunity = ProjectDemand(
project_id=id,
project_name=name,
value=value,
phase=ProjectPhase.PURSUIT,
start_date=expected_start,
end_date=expected_start + timedelta(days=duration_months * 30),
probability=win_probability,
resource_needs=needs
)
self.pipeline[id] = opportunity
return opportunity
def _calculate_resource_needs(self, value: float,
phase: ProjectPhase) -> Dict[ResourceRole, float]:
"""Calculate resource needs based on project value and phase."""
needs = {}
for role, ratio in self.STAFFING_RATIOS.items():
base_need = value / ratio
# Apply phase factor
phase_key = role.value.split('_')[0][:3]
factor = 1.0
if phase in self.PHASE_FACTORS:
factor = self.PHASE_FACTORS[phase].get(phase_key, 1.0)
needs[role] = base_need * factor
return needs
def get_current_capacity(self) -> Dict[ResourceRole, float]:
"""Get current capacity by role."""
capacity = {role: 0.0 for role in ResourceRole}
for member in self.staff.values():
if member.availability_date <= datetime.now():
capacity[member.role] += member.capacity
return capacity
def get_capacity_at_date(self, target_date: datetime) -> Dict[ResourceRole, float]:
"""Get projected capacity at future date."""
capacity = {role: 0.0 for role in ResourceRole}
for member in self.staff.values():
if member.availability_date <= target_date:
capacity[member.role] += member.capacity
return capacity
def calculate_demand(self, target_date: datetime,
include_pipeline: bool = True,
pipeline_threshold: float = 0.0) -> Dict[ResourceRole, float]:
"""Calculate resource demand at date."""
demand = {role: 0.0 for role in ResourceRole}
# Active projects
for project in self.projects.values():
if project.start_date <= target_date <= project.end_date:
for role, need in project.resource_needs.items():
demand[role] += need * project.probability
# Pipeline (weighted by probability)
if include_pipeline:
for opp in self.pipeline.values():
if opp.probability >= pipeline_threshold:
if opp.start_date <= target_date <= opp.end_date:
for role, need in opp.resource_needs.items():
demand[role] += need * opp.probability
return demand
def identify_gaps(self, horizon_months: int = 12) -> List[CapacityGap]:
"""Identify capacity gaps over forecast horizon."""
gaps = []
for month in range(horizon_months):
period_start = datetime.now() + timedelta(days=month * 30)
period_end = period_start + timedelta(days=30)
capacity = self.get_capacity_at_date(period_start)
demand = self.calculate_demand(period_start, include_pipeline=True)
for role in ResourceRole:
cap = capacity.get(role, 0)
dem = demand.get(role, 0)
gap = cap - dem
if gap < 0:
severity = "critical" if gap < -1 else "warning"
gaps.append(CapacityGap(
role=role,
period_start=period_start,
period_end=period_end,
demand=dem,
capacity=cap,
gap=gap,
severity=severity
))
return gaps
def can_pursue_project(self, value: float, start_date: datetime,
duration_months: int) -> Dict:
"""Evaluate if organization can pursue new project."""
# Calculate needs for potential project
needs = self._calculate_resource_needs(value, ProjectPhase.CONSTRUCTION)
end_date = start_date + timedelta(days=duration_months * 30)
# Check capacity over project duration
can_staff = True
bottlenecks = []
current_date = start_date
while current_date <= end_date:
capacity = self.get_capacity_at_date(current_date)
demand = self.calculate_demand(current_date)
for role, need in needs.items():
available = capacity.get(role, 0) - demand.get(role, 0)
if need > available:
can_staff = False
bottlenecks.append({
"date": current_date,
Truncated for display — read the full file on GitHub.
Related Skills
Agent-Reach
113.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
ruflo
82.1k🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
headroom
80.2kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Claude-Code-Game-Studios
40.2kTurn Claude Code into a full game dev studio — 49 AI agents, 75 workflow skills, and a complete coordination system mirroring real studio hierarchy.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
