The Bottleneck Never Disappears

Subscribe to The Durability Curve on Substack — free weekly analysis on AI infrastructure, verification, and durable systems.

In 1956 a container ship cut loading costs by 97 percent. The bottleneck did not disappear. It migrated. This is Law I: how value moves when constraints shift.

The bottleneck never disappears. It migrates. Where it goes next determines who wins.

In 1956 a retired trucking executive named Malcolm McLean watched a ship being loaded in New Jersey. The work was slow, dangerous, and expensive. Dockworkers moved thousands of individual crates, barrels, sacks, and boxes by hand. A single ship could sit in port for days. Loading cost roughly six dollars per ton.

McLean solution was a steel box. The container. Standardised, stackable, transferable between truck, train, and ship without opening it. His first ship, the Ideal X, sailed from Newark to Houston in April 1956 carrying fifty-eight containers. The cost to load that ship: sixteen cents per ton. A ninety-seven percent reduction.

The shipping industry declared the bottleneck solved.

They were right that dock labour was no longer the constraint. They were wrong that the bottleneck had disappeared. It had migrated.

Once loading became cheap and fast, the scarce thing became the container ports that could handle the new boxes. The cranes that could lift them. The rail lines that could move them inland. The customs systems that could clear them. The inventory software that could track them. The logistics networks that could coordinate them. The ship stopped being the unit of competition. The network became the unit of competition.

But migration is not always upward.

When IBM solved hardware integration with the PC in 1981, value did not migrate upward to system integrators. It migrated laterally to Intel and Microsoft. PC manufacturers competed on price, driving margins to two to five percent. Component suppliers captured twenty to forty percent plus. The bottleneck moved sideways because the stack architecture allowed it. The constraint did not disappear. It relocated in a direction most analysts did not predict.

This is Law I: the bottleneck never disappears. It migrates. The direction of migration depends on stack architecture, complement dynamics, and vertical integration strength. But the one thing it never does is stay in the same place.

The Law

When any layer becomes abundant or automated, value and scarcity migrate to the coordinating, verifying, or selecting layer above it. Generation gets cheap. Verification gets scarce. Information gets cheap. Judgement gets scarce. Tools get cheap. Integration gets scarce. Production gets cheap. Coordination gets scarce.

The mistake is treating a solved bottleneck as permanently solved. It rarely stays in the same place for long. Solving a constraint does not remove the constraint from the system. It moves the constraint to a different part of the system.

The published note puts it in operator language: 'Every fix you ship does not eliminate the constraint. It moves it. The skill is not fixing it. It is choosing which one to relax this quarter, while staying honest about the one you just made worse.'

Part of the Five Laws of Durable Systems framework — five tests for seeing what survives when surfaces change.

The Pattern Across Domains

The same structure repeats across fields that have nothing in common except this migration pattern.

Containerisation. The Ideal X cut loading cost by two orders of magnitude. Ports that could not adapt lost traffic to those that could. Rotterdam and Singapore built container terminals while other ports declined. The bottleneck migrated from the dock to the network of ports, rail, trucking, and customs that made containers useful. The companies that captured value were not the shipping lines but the logistics coordinators. The freight forwarders, the port operators, the software companies that tracked containers through the supply chain.

Personal computing. The IBM PC made hardware abundant. Multiple manufacturers could build compatible machines. The bottleneck migrated upward to the operating system. Microsoft captured it with MS-DOS and Windows, earning margins the hardware makers never saw. When the OS matured, the bottleneck migrated again to distribution channels and application ecosystems. The hardware abundance did not create software abundance in the economically relevant sense. It made the layer above the hardware decisive.

Information markets. The web made publishing near-free. The bottleneck migrated from production to attention and curation. Google captured it with PageRank, Facebook with the News Feed. Herbert Simon saw this coming in 1971. 'A wealth of information creates a poverty of attention.' The pattern predates the internet. Printing did the same thing in the fifteenth century. Books became cheap. The bottleneck moved to literacy and interpretation.

Photonics and AI infrastructure. In 2022 the visible bottleneck was GPUs. Nvidia data center revenue grew from roughly three billion dollars to over fifty billion in three years. The market poured capital into compute capacity. By early 2026 the next bottlenecks were already visible: advanced packaging capacity at TSMC, optical interconnects between GPUs, power delivery for data centres, grid interconnection lead times stretching to four years.

The clearest empirical signal came from Nvidia May 2026 earnings. Data centre networking revenue hit fourteen point eight billion dollars, up one hundred and ninety-nine percent year over year. Compute grew seventy-seven percent. The network layer grew at two point six times the rate of the compute layer. Within a single company revenue breakdown, the bottleneck was visibly migrating from GPU FLOPs to inter-GPU bandwidth. The GPU was only the first scarce thing. Buying more GPUs reveals the scarcities that were hidden underneath the GPU constraint.

Helium and the backward cascade. In May 2026, strikes on Qatar Ras Laffan facility destroyed roughly thirty-three percent of global helium production capacity. Helium is critical for semiconductor fabrication. This creates a potential bottleneck that loops backward through the manufacturing stack. Compute was solved. Bandwidth was being solved. Power was constrained. And now the substrate beneath all of them may re-bind. The bottleneck does not always move forward. It can move backward through the stack.

Every one of these stories follows the same arc. Solve one constraint. The constraint moves. The players who aimed at the old one lose. The players who aimed at the new one win.

Why This Happens

Bottleneck migration is not a coincidence. It is a structural property of complex systems. Three drivers make it inevitable.

First, solving one constraint reveals the next. A constraint hides the constraints below it. While GPUs were scarce, nobody paid attention to power because power was not yet limiting anything. The GPU masked it. When enough GPUs arrived, power became the binding constraint. The bottleneck cascade is not a series of unrelated problems. It is a sequence where each solved problem exposes the one underneath.

Second, capital overshoots the visible bottleneck. The visible constraint attracts investment, talent, and attention. Markets systematically over-allocate to it precisely because it is visible. This creates artificial abundance that forces the system to reveal the next constraint. The overshoot is not a bug. It is the mechanism by which the system migrates. Container shipping did not just solve the loading problem. It created more trade, more ports, and more logistics complexity than anyone predicted.

Third, abundance in one layer changes the economics of adjacent layers. Cheap shipping made inland logistics matter more. Cheap computing made software matter more. Cheap GPUs make power and interconnects matter more. The cost reduction in one layer raises the relative importance of everything that connects, verifies, or distributes the output of that layer.

Most bottleneck analyses treat constraints as pre-existing obstacles waiting to be found. The sharper insight is that solving a bottleneck creates the next bottleneck by changing the system economics. Abundance is not passive. It increases demand, raises expectations, alters adjacent cost curves, and makes previously irrelevant frictions suddenly decisive.

The Mistake Most People Make

The old constraint stays visible long after it has stopped deciding the outcome.

Analysts keep tracking GPU shipments long after the binding constraint has moved to power and interconnects. Investors keep asking about operating margins long after the bottleneck has moved to customer acquisition. Teams keep optimising model accuracy long after the bottleneck has moved to deployment reliability.

This error is not stupidity. It is structure. The systems that measured the old bottleneck are still in place. The dashboards still track the old metric. The compensation still rewards the old behaviour. By the time the data shows the migration has happened, the window to act has passed.

The Test

The question is simple: if this layer becomes abundant, where does scarcity move next?

Apply it to any layer you are watching. Compute becomes abundant. Scarcity moves to interconnects and power. Information becomes abundant. Scarcity moves to attention and verification. Capital becomes abundant. Scarcity moves to distribution and trust. Models become abundant. Scarcity moves to evaluation and contracts.

The question forces you to locate the next constraint before it becomes visible to everyone. That is the only time window in which the insight has value. Once the next bottleneck is widely recognised, the migration has already happened and the returns have already been captured.

What Would Break This Law

A permanently solved bottleneck with no migration. In fifty years of accelerating technological change across sixty-plus sources and fourteen-plus domains, no example of that exists. Every layer that has been made abundant has moved value to a new constraint elsewhere.

The closest candidates are instructive. Long-distance telephony was destroyed by cheap IP calling. A constraint disappeared. But a new one emerged at the access layer. Let Encrypt made DV SSL certificates free. Certificate profits collapsed. But the constraint migrated to trust verification and certificate management at scale. DRAM appeared to be a permanently commoditised market for twenty years until HBM memory for AI created a new scarcity at the advanced packaging layer.

The bottleneck never disappears. It migrates. The direction is never guaranteed to be upward. But it is guaranteed to move.

Three Applications

If you run a product team and your biggest concern is model quality, ask what happens when models become abundant. The scarce thing will not be a better model. It will be the evaluation, safety, and integration layer that determines which model is worth trusting.

If you invest in AI infrastructure and you are watching GPU supply, ask what happens when GPU supply catches up. The scarce thing will be power, networking, and the verification layer that proves the infrastructure is delivering value.

If you manage a supply chain and you are optimising factory throughput, ask what happens when throughput increases. The scarce thing will be the timing and coordination between factories, not the output of any single factory.

The Question That Matters

Every fix you ship does not eliminate the constraint. It moves it. The skill is not fixing it. It is choosing which one to relax this quarter, while staying honest about the one you just made worse.

Where is the bottleneck migrating to, and are you building there?

Subscribe to The Durability Curve on Substack — free weekly AI infrastructure analysis.

Premium research reports on Gumroad — in-depth investment theses and frameworks.