thinking-theory-of-constraints

Original：🇺🇸 English

Translated

When throughput or latency is pipeline-limited, identify the single binding constraint and exploit, subordinate, elevate, then recheck—ignore non-constraints.

2installs

Sourcetjboudreaux/cc-thinking-skills

Added on2026-08-14

NPX Install

npx skill4agent add tjboudreaux/cc-thinking-skills thinking-theory-of-constraints

SKILL.md Content

View Translation Comparison →

Theory of Constraints

A throughput-limited system has one binding constraint. Improve only that constraint; local optimization of non-constraints wastes effort and often grows WIP.

When to Use

Latency or throughput goal where one stage dominates time or rate.
Work piles up before one stage; downstream idles.
Adding capacity/workers elsewhere does not raise end-to-end output.
Need ordered plan: exploit cheaply before spending to elevate.

When NOT to Use

Load is spread; no stage dominates—use systems for interactions.
Problem is correctness/fault, not flow rate—debug the fault.
Bottleneck hops every run due to coupling/contention without a stable stage—systems or concurrency design, not five focusing steps.
Constraint already known and a cheap fix is ready—apply it without ceremony.

Procedure

Define the flow and goal. Name the unit of work (request, job, PR, record) and the metric that matters (end-to-end rate or latency).
Identify the constraint with evidence. Compare stages on utilization, queue/wait, and throughput. Constraint signals: near-100% use, longest queue, lowest stage rate, work piles here, more input does not raise system output. Prefer measured rates over opinions. If two candidates tie, pick the one whose improvement would raise system throughput first.
Exploit (no major spend). Maximize constraint output: cut idle, drop nonessential work on the constraint, reduce rework/setup, protect its time, improve quality at the constraint so output is not wasted. Estimate gain before spending.
Subordinate non-constraints. Pace upstream to constraint rate; do not flood WIP. Make other stages serve the constraint (readiness, clarity, immediate pull). Reject local utilization targets that grow queues before the constraint.
Elevate only if still short. After exploit is maxed, invest to raise constraint capacity (people, tooling, sharding, parallel path). Choose cheapest adequate elevation.
Recheck (prevent inertia). After elevation or large exploit, remeasure all stages—the constraint often moves. Return to step 2. Do not keep optimizing the old constraint.

Stop when constraint, evidence, exploit plan, subordination rules, and elevate-or-not decision are explicit—or when no single stage binds (exit to systems).

Output

text

system_goal: <throughput/latency objective>
flow: <stage sequence>
constraint: <stage or resource>
evidence: <utilization / queue / rate facts>
exploit: <actions, expected gain>
subordinate:
  - stage: <name>
    change: <how it serves the constraint>
elevate: <none | option + cost/gain>
next_constraint_watch: <what to remeasure after change>

Verification

Falsify: If raising the named stage cannot increase system throughput (another stage already caps), identification is wrong. If non-constraint optimizations change end-to-end rate, re-identify.
Stop: Do not elevate before exploit is exhausted. Do not optimize multiple stages “just in case.”
Over-application guard: One constraint at a time. Idle capacity upstream is not a problem to fill. Do not use TOC language for pure multi-loop emergence without a binding stage.