Skill

/thinking-theory-of-constraints

Use when optimizing latency or throughput in a pipeline and one stage dominates—focus all effort on that single bottleneck, since speeding up the others changes nothing until it's fixed.

One skill from thinking-skills.

shell

$ npx -y skills add tjboudreaux/cc-thinking-skills --skill thinking-theory-of-constraints --agent claude-code

Installs just this skill. Get the whole plugin for auto-invocation.

How it fires

How this skill gets triggered: by you, by Claude, or both.

Fires itselfClaude auto-loads it when your prompt matches the work.
You can call itInvoke it directly when you want it.
Slash command/thinking-theory-of-constraints

Context preview

The summary Claude sees to decide when to auto-load this skill.

Use when optimizing latency or throughput in a pipeline and one stage dominates—focus all effort on that single bottleneck, since speeding up the others changes nothing until it's fixed.

Stats

Stars863

Forks126

LanguageJavaScript

LicenseMIT

Ships with thinking-skills

SKILL.md

thinking-theory-of-constraints.SKILL.md

---
name: thinking-theory-of-constraints
description: Use when optimizing latency or throughput in a pipeline and one stage dominates—focus all effort on that single bottleneck, since speeding up the others changes nothing until it's fixed.
---

# Theory of Constraints

## Overview

The Theory of Constraints (TOC), from Eliyahu Goldratt's "The Goal," says a throughput-limited system has exactly one constraint setting its rate. Optimizing anything else is wasted effort—often counterproductive. Find the bottleneck, exploit it, subordinate everything else to it, and only then elevate it.

**Core Principle:** A chain is only as strong as its weakest link. Strengthening any other link does nothing.

## When to Use

- Latency optimization where one stage dominates the time budget
- Throughput optimization where one stage caps the rate
- A pipeline where work piles up before one specific stage

```
Trying to improve latency/throughput?
  → Have you identified the constraint? → no → FIND THE CONSTRAINT FIRST
  → Are you optimizing a non-constraint? → yes → STOP, FOCUS ON CONSTRAINT
  → Is the constraint working at 100%?   → no → EXPLOIT BEFORE ELEVATING
```

## When NOT to Use

- **No single stage dominates** (latency/load is spread roughly evenly, or many stages are near 100%) → there is no one constraint to exploit. Use `thinking-systems` to model the interactions instead.