thinking-theory-of-constraints

Identifies and resolves the single binding constraint limiting system throughput or latency.

Updated May 24, 2026
One-click install
npx skills add https://github.com/MWest2020/skill-forge --skill thinking-theory-of-constraints-mwest2020
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: thinking-theory-of-constraints
Source: https://github.com/MWest2020/skill-forge/tree/main/skills/thinking-theory-of-constraints
Command: npx skills add https://github.com/MWest2020/skill-forge --skill thinking-theory-of-constraints-mwest2020

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? When a pipeline's throughput or latency is capped by one stage, teams often waste effort optimizing non-constraints. This Skill applies the Theory of Constraints five focusing steps to find the true bottleneck and improve only what matters. ## Core Features & Use Cases - Constraint Identification: Uses evidence like utilization, queue depth, and stage throughput to pinpoint the single binding constraint. - Ordered Improvement Plan: Walks through exploit, subordinate, elevate, and recheck steps so cheap fixes come before capacity spending. - Structured Output: Produces a template covering system goal, flow, constraint evidence, exploit actions, subordination rules, and elevation decisions. - Use Case: A CI/CD pipeline where builds pile up before one slow test stage—use this Skill to confirm the constraint, pace upstream work to its rate, and decide whether elevation is justified. ## Quick Start Apply the theory of constraints to diagnose why my deployment pipeline is slow and produce an exploit and subordinate plan.

Frequently Asked Questions about thinking-theory-of-constraints

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I find the bottleneck in a processing pipeline?

Compare each stage on utilization, queue length, and throughput. The binding constraint shows near-100% utilization, the longest queue, and the lowest stage rate, and adding input elsewhere does not raise system output.

What are the five focusing steps of Theory of Constraints?

Identify the constraint with evidence, exploit it without major spend, subordinate all other stages to its rate, elevate capacity only if still short, then recheck because the constraint often moves after improvement.

When should I not use Theory of Constraints?

Avoid it when load is spread evenly with no dominant stage, when the problem is correctness or faults rather than flow rate, or when the bottleneck hops every run due to coupling. Those cases call for systems thinking or debugging instead.

Why does optimizing non-bottleneck stages not improve throughput?

System output is capped by the constraint, so speeding other stages only grows work-in-progress queues before it. Local utilization gains on non-constraints do not change end-to-end rate and often add waste.

When should I elevate a constraint instead of exploiting it?

Elevate only after exploitation is exhausted—idle time removed, nonessential work dropped, rework reduced. Then invest in capacity such as people, tooling, or sharding, choosing the cheapest adequate option, and remeasure all stages afterward.