The Domino That Already Fell

It is two in the morning and a production incident is open. Someone with the right access opens the cloud console, clicks into a load balancer, bumps a timeout, adds a firewall rule, and the pager goes quiet. Relief all around. By the next afternoon nobody can say exactly what changed, who changed it, or how to undo it cleanly, because the change lives only in the running system and in one tired person’s memory. If that scene makes you wince, it is because the infrastructure world already lived through it and already fixed it. How it fixed it is the template for everything else this series is about.

I argued in the first post that software spent decades earning a governed lifecycle for exactly one artifact, source code, and that AI now makes running that lifecycle cheap enough to point at every versionable deliverable. Infrastructure is where that generalization already happened once, in full view, with tools you can name. It is the domino that already fell. Watch how it fell and the rest of the dominoes stop looking hypothetical.

What GitOps actually moved

The move was not “write your servers in code.” That was Infrastructure as Code, and it was necessary but not sufficient. The move that mattered was making a git repository the single declared source of truth for what the system should be, and then having the system continuously make itself match.

The GitOps principles state it plainly: the desired state is declarative, versioned and immutable in git, pulled automatically, and continuously reconciled. Read that list again with a non-infra artifact in mind and it stops sounding like a Kubernetes convention and starts sounding like a governance contract. A single authoritative copy. Every change tracked. A machine that notices when reality drifts from the declared intent and pulls it back.

That is the same desired-state reconciliation I wrote about in The Reconciliation Loop, so I will not relitigate the mechanism here. The point for this series is narrower and more useful: infrastructure is the existence proof. Somebody already took a class of change that used to happen by clicking around at two in the morning and forced it through a reviewed, versioned, reconciled pipeline, and the sky did not fall. It got quieter.

The reconciler is the point

The piece people underweight is the reconciler, because it is the piece with no analog in the old world. A pipeline that deploys once and walks away is just a fancier click. A reconciler never walks away.

Argo CD and Flux sit inside the cluster and do one thing forever: compare the live state against what git says it should be, and close the gap. It is the same control loop Kubernetes controllers run for every object they manage, lifted up to the level of your whole declared platform. Someone edits a setting by hand in the console, and the reconciler notices the drift and reverts it, because the console is no longer the source of truth. The git repo is.

This buys three things worth naming precisely, because later posts will reach for each one. Drift detection: the system tells you when reality and intent diverge, instead of you finding out during the next incident. Self-healing: it does not just alert, it corrects. And rollback that is not a special procedure but a plain git revert, because if the desired state is a commit, undoing it is undoing a commit. Recovery stops being a heroics exercise and becomes an ordinary operation any reviewer can read before it happens.

Hold that shape in your head. Source of truth, a reconciler that watches, drift caught, rollback by revert. Nothing in it is specific to servers. That is the whole reason the series exists.

Why infrastructure went first

If the pattern is so general, why did infrastructure get it a decade before anything else? Three reasons, and each one is a clue about what makes the next domino fall.

The blast radius was undeniable. A bad manual change to production infrastructure took down real systems for real money in real time, so the pain of doing it by hand was impossible to ignore and impossible to defer. The tooling matured because the market was enormous, so Terraform and the GitOps controllers had years of investment behind them. And infrastructure has a clean test: you can ask, mechanically, whether the live state matches the declared state, and get a true or false answer. Convergence is checkable.

Those three, sharp pain, mature tooling, and a checkable test, are exactly the conditions that justified paying for the discipline. For most other enterprise artifacts, the pain was diffuse, the tooling absent, and the test fuzzy, so the math never closed. What changed, as I argued in the pillar, is that the cost of running the loop collapsed. The pain and the tooling arguments now clear for far softer artifacts than servers. Which leaves only the third condition, the checkable test, as the real frontier, and I will come back to it.

The gap AI exposed

Here is where the infrastructure story turns into a warning rather than a victory lap. AI can now write your Terraform. It is genuinely good at it. And that competence exposed how few organizations were actually ready to receive it.

I made this case in detail in AI Can Write Your Terraform. Can Your Organization Deploy It?: the bottleneck was never generating the configuration, it was the governed path the configuration has to travel before it touches production. Hand a fast generator to an org with no GitOps and no policy gates and you have not sped anything up, you have just industrialized the two in the morning console click. The generator makes the change cheap; without the reconciler, the review, and the policy check, it also makes the mistake cheap and frequent.

That is the distinction I drew in Don’t Vibe Your Infrastructure, between building a thing and operating it. GitOps is what lets you accept AI-generated change at volume, because every proposal lands as a reviewable, revertible commit against a declared desired state, and the reconciler is the backstop when a human misses something. Speed without that pipeline is not velocity. It is exposure.

What infrastructure had that the rest will not

I want to end on the honest limit, because it is the hinge for the whole series. Infrastructure got the governed lifecycle first partly because it had a gift the other artifacts lack: a machine-checkable definition of correct. Did the live state converge to the declared state, yes or no. The reconciler can answer that without a human in the loop.

A risk standard does not converge. A policy does not throw a diff error when a single word quietly changes what a control requires. An architecture decision has no green checkmark that fires when the design drifts from intent. The source of truth, the change ticket, the review, the promotion, all of that transfers cleanly to those artifacts, and later posts will show exactly how. The reconciler’s automatic test does not transfer, and pretending otherwise is how you get governance theater at machine speed. That missing test is the hard problem the rest of this series has to earn its way through, and I will spend a whole post on it.

Infrastructure fell first because it was easiest, not because it was special. The pattern was always general. So the question the rest of the series keeps asking is the one the pillar opened with: if this worked for the hardest-blast-radius artifact in the building a decade ago, why is everything else still living at two in the morning with a console and a tired memory?

---

If this resonated, read I Already Solved This, the pillar this series hangs from, and The Reconciliation Loop, on the desired-state pattern underneath GitOps. Both sit alongside this one in the Everything as Code series.

Find me on X @orestesgarcia or LinkedIn /in/setsero.