capacity-constraint-analyzer
Production capacity analysis skill using Theory of Constraints principles
Best use case
capacity-constraint-analyzer is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Production capacity analysis skill using Theory of Constraints principles
Teams using capacity-constraint-analyzer should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/capacity-constraint-analyzer/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How capacity-constraint-analyzer Compares
| Feature / Agent | capacity-constraint-analyzer | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Production capacity analysis skill using Theory of Constraints principles
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Capacity Constraint Analyzer
## Overview
The Capacity Constraint Analyzer provides production and supply chain capacity analysis using Theory of Constraints (TOC) principles. It identifies bottlenecks, models capacity exploitation strategies, and supports capacity investment decisions.
## Capabilities
- **Capacity Utilization Calculation**: Resource utilization analysis
- **Bottleneck Identification**: Constraint and limiting factor detection
- **Constraint Exploitation Strategies**: TOC-based improvement approaches
- **Capacity Adjustment Modeling**: Expansion and contraction scenarios
- **Lead Time Impact Analysis**: Capacity effects on delivery performance
- **Rough-Cut Capacity Planning**: Aggregate capacity assessment
- **Finite Capacity Scheduling Support**: Detailed scheduling inputs
- **Capacity Investment Analysis**: CapEx decision support
## Input Schema
```yaml
capacity_analysis_request:
resources:
work_centers: array
- resource_id: string
name: string
available_capacity: float
capacity_unit: string
efficiency: float
setup_time: float
labor: array
equipment: array
demand_requirements:
production_plan: array
capacity_requirements: array
- resource_id: string
product: string
rate: float
constraints:
operating_hours: object
maintenance_windows: array
policy_limits: object
analysis_parameters:
time_horizon: string
granularity: string
scenarios: array
```
## Output Schema
```yaml
capacity_analysis_output:
utilization_analysis:
by_resource: array
- resource_id: string
name: string
available_capacity: float
required_capacity: float
utilization_percent: float
status: string # under, balanced, constrained, over
summary: object
bottleneck_identification:
constraints: array
- resource_id: string
constraint_type: string
impact: string
root_cause: string
constraint_ranking: array
exploitation_strategies:
recommendations: array
- strategy: string
target_resource: string
expected_improvement: float
implementation_effort: string
capacity_scenarios:
scenarios: array
- scenario_name: string
capacity_changes: object
cost: float
benefit: float
lead_time_impact: string
investment_analysis:
options: array
npv_comparison: object
payback_analysis: object
rough_cut_capacity_plan: object
```
## Usage
### Bottleneck Identification
```
Input: Production plan, resource capacities
Process: Calculate utilization, identify constraints
Output: Bottleneck report with ranking
```
### Capacity Scenario Analysis
```
Input: Demand growth scenarios, current capacity
Process: Model capacity options and impacts
Output: Capacity scenario comparison
```
### TOC Exploitation Strategy
```
Input: Identified constraint, current operations
Process: Apply TOC principles for exploitation
Output: Constraint exploitation recommendations
```
## Integration Points
- **ERP/MES Systems**: Capacity and production data
- **Planning Systems**: Demand and production plans
- **Scheduling Systems**: Finite capacity scheduling
- **Tools/Libraries**: Theory of Constraints frameworks, scheduling algorithms
## Process Dependencies
- Capacity Planning and Constraint Management
- Sales and Operations Planning (S&OP)
- Supply Chain Network Design
## Best Practices
1. Validate capacity data accuracy
2. Consider all constraint types (physical, policy, market)
3. Focus improvement efforts on true constraints
4. Model multiple demand scenarios
5. Include maintenance in capacity calculations
6. Review capacity plans monthlyRelated Skills
terraform-analyzer
Specialized skill for analyzing Terraform configurations. Supports parsing, security scanning (tfsec, checkov), cost estimation (infracost), drift detection, and plan visualization across AWS, Azure, and GCP.
db-query-analyzer
Analyze database query performance with execution plans and index recommendations
code-complexity-analyzer
Analyze code complexity metrics including cyclomatic complexity, code smells, and technical debt
cloudformation-analyzer
Validate and analyze AWS CloudFormation templates for security and best practices
semantic-code-analyzer
LLM-powered semantic analysis of code diffs to detect business-logic trojans
sast-analyzer
Static Application Security Testing orchestration and analysis. Execute Semgrep, Bandit, ESLint security plugins, CodeQL, and other SAST tools. Parse, prioritize, and deduplicate findings across multiple tools with remediation guidance.
crypto-analyzer
Cryptographic implementation analysis and validation for encryption algorithms, key sizes, and certificate management
semver-analyzer
Analyze code changes and determine semantic version bumps. Detect breaking changes automatically, suggest version bump (major/minor/patch), generate changelog entries, and validate version consistency.
api-diff-analyzer
Compare API specifications to detect breaking changes. Compare OpenAPI spec versions, categorize changes by severity, generate migration guides, and block breaking changes in CI.
process-analyzer
Analyze processes, identify workflows, define boundaries and scope, and map process requirements for specialization creation.
timing-constraints
Expert skill for developing and validating timing constraints. Writes SDC (Synopsys Design Constraints) and XDC files for FPGA timing closure.
scope-logic-analyzer
Test equipment integration for signal analysis (oscilloscope and logic analyzer)