The Constraint Ladder: where your bottleneck goes after you fix it

In Eliyahu Goldratt's The Goal, the 1984 novel that shaped modern operations thinking, a plant manager takes his son's scout troop on a hike and watches the whole line move at the pace of Herbie, the slowest hiker, no matter how fast the others walk. The fix isn't making everyone faster. It's putting Herbie at the front, lightening his pack, and pacing the line to him. Back at the factory, the same law holds: the plant's throughput is set entirely by one heat-treat furnace, and every "efficiency" gained elsewhere just builds mountains of inventory in front of it.

The Theory of Constraints compresses to two consequences, and both are brutal for the default AI strategy. An hour lost at the constraint is an hour lost for the entire system: if code review is your bottleneck, your reviewers' attention is literally your company's delivery capacity. And an hour saved at a non-constraint is a mirage: it ships nothing sooner. With AI it's worse than a mirage, because an accelerated non-constraint manufactures inventory for the constraint to drown in. AI aimed at a non-constraint is a waste amplifier.

That second consequence explains most of the industry's paradox data since 2023. Code generation was, in most organizations, not the constraint. The industry aimed the most powerful acceleration in its history at one of the fastest steps in the stream, and is now surprised by the pile.

But here's what the paradox coverage misses: relieving a constraint doesn't make a system unconstrained. The constraint moves. And in AI-adopting software organizations, it moves in a sequence predictable enough that we've started drawing it as a ladder.

Reading the rungs

• Rung 1, writing code. The 2022–24 constraint in the demo, rarely in reality. If you had a backlog of well-specified work and developers typing rather than waiting, this was yours, and assistants genuinely solve it.
• Rung 2, code review. The signals: PR age rising while time-to-open-a-PR falls, diff sizes creeping up, approvals arriving faster than anyone could have read the change.
• Rung 3, test and environments. Environment-by-ticket waits, flaky suites re-run on faith, QA reopen loops full of "almost right."
• Rung 4, release and approvals. Finished work queuing for the release train; sign-offs that carry ceremony but no information.
• Rung 5, deciding what to build. Delivery outruns discovery; teams sit idle awaiting product clarity; you get fast at building the wrong thing. This is where spec-driven beats vibe-driven.
• Rung 6, customer absorption. You can ship faster than users can absorb change. A good problem, and still a problem.

Most organizations are standing on rung 2 right now. Reviewer attention is the scarcest resource in an AI-heavy stream, and it degrades under exactly the load AI creates: defect detection falls off sharply beyond roughly 400 lines per review session, while AI makes the 800-line diff as cheap to produce as the 80-line one. That yields the most expensive sentence in modern engineering: every dollar spent on code generation while standing on rung 2 buys inventory, not throughput.

The play at each rung is different

The Theory of Constraints comes with an algorithm, the Five Focusing Steps, and it maps onto AI deployment cleanly:

• Identify: read the map; the longest queue and the oldest work in progress both point at the constraint. It is almost never typing speed.
• Exploit: get more from the constraint without buying capacity. This is where AI goes first: first-pass review triage at the review choke, test generation at the QA choke, spec drafting at the decision choke.
• Subordinate: pace everything else to the constraint's rhythm, including the agents. Caps on open AI PRs per reviewer. Sometimes this genuinely means slowing AI output down.
• Elevate: only if the constraint still binds, add capacity: restructure review, grow the bench, invest in platform. Expensive, which is why it's step four, not step one.
• Repeat: the constraint moves. Re-map, and retire the policies built for the old constraint before inertia turns them into the new one.

Notice where AI appears: step two, after the constraint is identified and before anyone spends on capacity. Most rollouts run the steps in reverse: buy capacity everywhere, identify nothing, subordinate nobody.

What the breadth data actually says

There's a pattern in the survey research that vendors read backward. Organizations applying AI broadly across the lifecycle report better delivery outcomes than narrow adopters, and the usual conclusion is "buy more use cases." The flow reading is sharper: breadth works because it is accidental constraint-following. Spread AI over ten stages and you can't help but hit the bottleneck occasionally. Deliberate constraint-following gets the same system effect at a fraction of the spend, because the one use case that matters right now gets the attention ten diluted ones don't.

The engineers running the furthest ahead have arrived at the same place from the other direction. Joe Magerramov, a VP and Distinguished Engineer at AWS, put it plainly after months of running an agentic engineering team: the teams that succeed with agentic development will be the ones who recognize that the entire software development lifecycle needs to evolve in concert.

The Sigao take

The ladder is your AI roadmap. Name the rung you're standing on, run the Five Focusing Steps at that rung, and expect the constraint to move, because a working fix guarantees it will. That reframe turns AI adoption from a series of surprises into a sequence you can plan capacity, tooling, and hiring around. The full treatment, including the 90-day playbook for your first pass and the flow policies that keep the gains, is in our whitepaper The Bottleneck Isn't the Model. If you want to locate your rung with data rather than instinct, our maturity assessment takes about ten minutes.

Sources

• Eliyahu M. Goldratt and Jeff Cox, The Goal: A Process of Ongoing Improvement, North River Press, 1984: the Five Focusing Steps and the constraint as the system's governor.
• DORA, Accelerate State of DevOps Report 2024 and State of AI-assisted Software Development 2025: the instability mechanism and the breadth-of-adoption finding.
• SmartBear, Best Practices for Peer Code Review: defect detection falling beyond ~400 lines per session, from the Cisco study of 2,500 reviews.
• Joe Magerramov, "The New Calculus of AI-based Coding", 2025.