Note: This is a research note supplementing the book Unscarcity, now available for purchase. These notes expand on concepts from the main text. Start here or get the book.

Infrastructure Inversion: When AI Outgrows Systems Built for Humans

In June 2026, Microsoft did something that should have been impossible. It started running GitHub, the world’s largest code-hosting platform, partly on Amazon Web Services.

Read that again. Microsoft owns GitHub. Microsoft owns Azure, the second-biggest cloud on Earth, a business it spends tens of billions a year defending against exactly one company: Amazon. And in June 2026, Microsoft quietly rented its archrival’s cloud to keep GitHub from falling over, because its own infrastructure could no longer absorb the load. That is not a partnership. That is a white flag with a logo on it.

What broke GitHub wasn’t a hack, an outage, or a botched migration. It was success of a very specific kind. The AI coding agents that the entire industry spent two years cheering for, the ones writing most of the code at frontier firms, finally arrived at scale, and the platform built for human programmers met a workload that humans could never have produced.

This is the Infrastructure Inversion: the moment when the systems we built to serve human throughput become the thing that constrains machine throughput. The scaffolding flips into the ceiling. And GitHub is just the first large, visible building to hit it.

The numbers that snapped the platform

GitHub’s COO confirmed the headline figure in April: the platform was processing 275 million commits per week. Annualize that and 2026 is on pace for roughly 14 billion commits, a 14x jump from the 1 billion commits recorded across all of 2025. Not 14% more. Fourteen times more, in a single year.

The pull-request data is even wilder, because PRs are where agents announce themselves. PRs opened by AI coding agents climbed from about 4 million in September 2025 to more than 17 million in March 2026 — a 325% surge in six months. GitHub Actions, the continuous-integration system that actually runs tests and builds, tells the same story in compute: weekly usage went from 500 million minutes in 2023, to 1 billion in 2025, to 2.1 billion minutes in a single week in early 2026.

The platform did what any human-scale system does when the curve goes vertical. It buckled. Nine separate service incidents in May. June availability sagged to roughly 88.4%, a galaxy away from the 99.9% uptime that enterprise contracts are written around. Hence the AWS lifeboat.

Here’s the kicker that makes the whole thing a parable rather than a press release: only about 1 in 10 AI-generated pull requests is actually legitimate. Nine-tenths of that record-shattering traffic is noise — agents opening PRs to fix things nobody asked to fix, retrying, second-guessing, generating work for human reviewers who cannot possibly keep up. GitHub melted its infrastructure to deliver, mostly, slop. We will come back to that, because it matters more than it looks.

What actually inverted

Every digital system you have ever used has a human assumption welded into its foundations. Not a stated one. A buried one, in the load math.

Login flows assume a person types a password every few hours, not an agent that re-authenticates a thousand times a minute. API rate limits assume “how many calls could a reasonably caffeinated developer make?” CI pipelines assume a build is triggered when a human finishes a chunk of work and pushes it, maybe a handful of times a day. Code review assumes a teammate reads the diff over coffee. CAPTCHAs assume the thing on the other end is trying to prove it’s human. Every one of those assumptions is a speed limit calibrated to flesh.

Agents do not honor any of them, because they were never told those numbers were the point. They operate at machine speed. One documented agent made 127,000 API calls in eight hours before anyone noticed it had gone feral. Another, stuck in a retry loop, fired 50,000 requests over six hours without ever tripping a single rate limit, because no individual request looked abnormal — only the aggregate, at machine cadence, was insane. Gartner projects that more than 30% of the growth in API demand will come from AI and LLM tools, and that the share of enterprise apps with embedded agents will leap from under 5% to 40% in a single year.

This is the inversion stated plainly: infrastructure designed around the question “what can a human plausibly do?” becomes the binding constraint the instant the actor is no longer human. The login page, the rate limiter, the review queue, the CAPTCHA, the CI runner — all of it was load-bearing furniture sized for people. Fill the room with agents and the furniture is the wall.

And note where it bites hardest. It is rarely the hyperscaler’s front door that fails. It’s the legacy database behind the shiny API, the internal service nobody load-tested for 10,000 concurrent queries, the quiet dependency three hops down. Abundance at the top of the stack finds the scarcest thing underneath and crushes it.

Why this is the book’s pattern, not a tech-news footnote

If you’ve spent any time in Unscarcity, this should feel familiar, because it is the engine of the entire book wearing a new costume.

The core move of the Unscarcity thesis is that abundance in one layer manufactures acute scarcity in the layer next to it. Make one input nearly free and demand stampedes toward whatever input is still expensive. We have watched this happen in slow motion across the tech triad:

Intelligence got cheap, so energy got scarce. That’s the Electron Gap: the bottleneck on AI is no longer algorithms, it’s megawatts. The cleverness is abundant; the electrons are not.
The AI buildout got large, so the grid got contested. That’s the fight over who pays for AI’s electricity, with data centers shoving a majority of regional price spikes onto ordinary ratepayers.
Compute got strategic, so warehouses of GPUs became the new oil fields, and the 100x annual improvement curve turned capex into a national-security question.

Infrastructure Inversion is the same physics applied to platform capacity. Coding intelligence became nearly free — the Substitution Threshold for writing software got crossed, the point where the cheapest reliable producer of a line of code stopped being a person. The instant that happened, the next input upstream became the constraint: the platform that hosts, builds, tests, and reviews the code. We made the coder abundant and discovered the coordination layer was scarce all along. We just couldn’t see it, because human coders never pushed it hard enough to notice.

This is why GitHub matters beyond GitHub. It is a clean, early, well-instrumented example of a transition every human-built system is going to make. Orchestrating fleets of agents is becoming the dominant way work gets done, and orchestration generates load the way a power plant generates heat — as an unavoidable byproduct of running at all.

You cannot out-provision an exponential

The reflexive fix is to buy your way out. Rent AWS. Raise the rate limits. Add GPUs. Spin up more runners. Microsoft has roughly infinite money and it still had to go borrow capacity from Amazon, which tells you how well “just add more” scales against a 14x year.

The arithmetic is brutal and worth saying out loud. Provisioning is a linear, lumpy, capital-intensive process gated by supply chains, permits, and power. Agentic demand is an exponential gated by nothing but how many agents people feel like launching this week. You do not win a footrace against an exponential by jogging faster. You lose it slightly later.

So the real fix is not more furniture. It is rebuilding the room.

That means infrastructure that is machine-native by design: rate limits denominated in actual resource consumption (tokens, compute, cost) rather than in “requests a human might send”; review and merge systems that assume most contributions arrive from agents and triage accordingly; capacity planning that treats a 10x demand spike as a Tuesday, not a once-a-decade disaster.

And critically, it means putting the human back in exactly one place: judgment. The 90%-slop problem is the tell. When agents can generate infinitely but the system can only absorb what humans can review, review becomes the scarce layer — and the answer is not to make humans review faster, which is impossible, but to gate agents at the decisions that actually matter. This is the human-in-the-loop checkpoint principle: let agents run wild on everything reversible, and require a human signature only at the irreversible actions. Machine speed for the work, human judgment for the commitments.

What the Foundation has to learn from a broken code platform

Here is the part that should make a policymaker sit up. The book’s Foundation is, at bottom, an infrastructure layer — the universal utility that delivers housing, energy, healthcare, coordination, and compute as a birthright. The whole proposition rests on infrastructure that works at civilizational scale.

GitHub on AWS is a warning shot for that proposition. If a platform run by the richest software company in history, staffed by some of the best infrastructure engineers alive, can be inverted in eighteen months by demand it cheered into existence, then any abundance infrastructure built on quietly human-scale assumptions will hit the same wall the moment agents become its primary users — and in the world the book describes, they will.

The design lessons fall straight out of the inversion:

Architect for machine-scale from day one. Compute as a civil right — Universal Basic Compute — only means something if the substrate is built to be hammered by autonomous demand, not sized for the human population’s typing speed.

Keep it open and forkable. A closed platform that inverts leaves its users stranded, renting capacity from a rival or simply going dark. Infrastructure built as open, forkable protocols rather than captured platforms can be scaled, routed around, and rebuilt by anyone when a node hits its ceiling. Openness is not an ideology here; it is a load-balancing strategy.

Govern at the irreversible edges. Abundance plus zero judgment is just faster catastrophe — the GitHub slop flood in civic clothing. The Foundation has to run at machine speed and gate the commitments at human conscience.

GitHub running on its competitor’s cloud is not an embarrassing footnote. It is the first clear photograph of the wall that every system designed for humans is going to meet, in code first because code moves fastest, and then in everything else. The choice it forces is the one the book has been hammering from page one: keep patching scarcity-era infrastructure until it seizes, or build the abundance-era infrastructure the world is actually walking into.

The agents aren’t the problem. The human-shaped assumptions we poured the foundations in are. And foundations, as the book keeps insisting, are exactly the thing worth rebuilding before the load arrives — not after.

Want the full argument for how abundance in one layer forces scarcity into the next, and what an infrastructure built for the machine age actually looks like? Read Unscarcity.

Infrastructure Inversion: When AI Outgrows Human Systems