The next article initially appeared on Charity Majors’s Substack and is being reposted right here with the writer’s permission.
A couple of days again I wrote a bit known as “AI lovers are in a race in opposition to time, AI skeptics are in a race in opposition to entropy.”
I’ve notes on an entire pile of AI-related subjects that I’d wish to cowl in depth: AI mandates, communication norms, code evaluate, AI artwork, and extra. Sadly, I received too many attention-grabbing responses to my final piece, and now I’ve to deal with these earlier than I can transfer on to different subjects. 😉
There have been two varieties of attention-grabbing responses: the primary on the technical deserves, the second on moral grounds. I’ll reply to every of those individually. Let’s take the technical aspect first, as a result of it’s simpler.
In some way, a subset of readers got here away believing I used to be telling everybody to ditch code evaluate and push their shittiest code straight into manufacturing with out studying it, proper now, tout suite.1
That’s not what I’m doing. That’s not what I feel you ought to do. However I didn’t choose that instance at random, and I’ll let you know why.
In 2025, the query was whether or not AI might ever generate “good” code
It’s straightforward to overlook, however for many of 2025, the concept AI-generated code was slop and may at all times be slop was not solely an affordable place to carry, it was the default, mainstream place.2
That query was answered decisively final November. Ever since Opus 4.5 got here out, AI has been capable of generate code that’s roughly nearly as good as that of the median software program engineer, not less than for widespread patterns, and far sooner and extra cheaply. I got here out of a e book gap and realized this in January, and over the primary few months of 2026, it appeared like everybody round me was having an identical realization.
However many noticed it coming a lot sooner.
The favored narrative holds that Opus 4.5 was what modified. However Opus 4.5 was extra just like the tipping level. Agentic harnesses (the code that wraps the LLM in a loop with instruments) turned an actual factor in mid 2025, with precursors constructing again to late 2024. Device use, operate calling, MCPs…all of this wave was constructing over the course of 2025, and crested into actual common function usability on the finish of the yr.
That’s what the lovers had been making an attempt to inform us final yr. Not solely “that is coming”, however “that is coming sooner than you assume.”
Because it seems, they had been proper.
It was affordable to be skeptical the primary time
As it’s possible you’ll know, I come from the reliability aspect of the home. The praise I’ll pay to myself and my individuals is that we don’t wrestle to adapt to new realities. As quickly as an issue is actual and in entrance of us, we regulate easily, even eagerly, because of an unwholesome zest for lapping up disgusting technical messes (and the campfire tales we get to inform later).
The un-compliment I’ll pay myself and my individuals is that we typically wrestle to just accept that progress is actual, that the continued existence of bugs and edge instances doesn’t diminish the truth that large swaths of downside house do get more-or-less solved over time, to the purpose they are often taken with no consideration by most individuals.3
The velocity at which code went from whole crap to “ah rattling, that’s not unhealthy” is what I’ve at the back of my thoughts, as lovers are telling us that harness engineering and AI validation is actual, it’s already right here, and it’s getting higher astonishingly quick.
Holding out for “I’ll imagine it once I see it” was forgivable the primary time, however a lot much less so the second time. That is what it feels wish to be on the within of an exponential change curve, seems.4
What occurred in 2025, precisely?
I wish to pause right here and be very clear about what I feel is going on. Then I’m going to let you know what particularly I’m enthusiastic about, and why.
You’re below no obligation to affix me there. However there are manner too many sweeping statements on the market proper now about “it was by no means X”—“it was at all times Y”—“the longer term belongs to xyzzy” 🤮—and I wish to be crystal clear how conditional and particular and contextual my claims are.
What occurred in 2025 was this: the economics of code manufacturing had been turned the wrong way up. As an alternative of being very onerous, time-consuming, and costly to generate code, it turned successfully free and instantaneous. Strains of code went from being treasured, reused, cared for and thoroughly curated, to being disposable and regenerable, virtually in a single day.
For many of computing historical past, the first manner individuals have realized to know software program is by writing the code. When you’ve achieved some mastery, studying and discussing code will get you a lot of the manner there. (I’d argue that software program engineers have at all times relied far too closely on the code as a substitute of sensemaking the system by way of observability.)
“The true product of a software program group is shared understanding”
Many nice software program engineers maintain that true product of each (good) software program engineering group has at all times been a shared understanding of the software program we personal. That it will get saved as cache state in our fragile little meat brains, continuously flushed to disk, deployed to manufacturing, dedicated to github, however our minds are the place which means has at all times lived.
Is it any marvel that software program has at all times been such a fiercely collectivist endeavor, exquisitely delicate to relationship dynamics and manners and questions of equity and emotional valence? It’s precisely what you’d anticipate when a part of your mind lives in different individuals’s brains, and your collective interdependence is sky excessive.
It’s one thing that I really like about this trade. However there’s no denying that minds have been a poor container for sure facets of the software program improvement mannequin. We’re forgetful, distractible, impatient. We’re unhealthy at recognizing small particulars, we develop habituated to repetition. Worst of all, the mannequin in our heads diverges massively and perpetually from the world our customers work together with.
Anyway, SREs have by no means fairly purchased that clarification. To us, it’s clear that the true product of each (good) software program engineering group is manufacturing.
Solely prod is prod. Take a look at in prod, or dwell a lie.
(That is all backstory. I get to the purpose, I promise.)
Seems, that is an engineering downside in any case
We issued our AI mandate final August.5 I had seen sufficient to know that this was taking place, and it was time to do the accountable factor. Honeycomb is a devtools firm, and other people come to us to assist with onerous issues on the forefront of know-how. I used to be all in on AI, however I can’t say I used to be tremendous enthusiastic about it, in my coronary heart of hearts.6
Then I discovered Chad Fowler’s writings on Phoenix Architectures.
In case you don’t know what I’m speaking about, you need to actually cease studying my shit proper now and go learn his. Chad is the man who coined the time period “immutable infrastructure” in 2013. His best-known essay is “Relocating Rigor”, as a result of Martin Fowler7 talked about it recapping a Thoughtworks meetup on the way forward for software program. I replied with “Manufacturing Is The place the Rigor Goes”, complaining that they didn’t discuss manufacturing sufficient.
After I wrote that, I feel “Relocating Rigor” was the one piece I had learn. However quickly I discovered the remainder of it, and after studying two or three essays, it simply clicked. I knew precisely what he was speaking about. I might predict the remainder of what he was going to say. After which, reader…then I received excited.
This has all occurred earlier than, and this may all occur once more
I’m going to present you a small pattern of Chad quotes, simply sufficient to get the gist. Right here’s one from “The Loss of life and Rebirth of Programming.”
Immutable infrastructure. Stateless providers. Containers. Blue-green deployments. Infrastructure as code.
These concepts all share a typical premise: by no means repair a operating factor. Substitute it.
AI pushes this premise past infrastructure and into utility code itself. When rewriting is reasonable, modifying in place turns into dangerous. Mutation accumulates entropy. Substitute resets it.
One other favourite: “The Deletion Take a look at.”
Right here’s a easy take a look at you possibly can apply to any software program system you’re employed on:
Think about deleting your complete implementation.
Most engineers expertise deletion as existential. Code feels just like the factor. It’s what we write, evaluate, model, deploy, and debug. Shedding it looks like shedding the system itself.
When individuals say, “We will’t simply throw the code away,” what they often imply is one thing extra exact:
- We don’t know precisely what conduct is required.
- We don’t know which failures are unacceptable.
- We don’t know what invariants should at all times maintain.
- We don’t know the right way to inform if a brand new model is right.
- We don’t know which bugs are intentional fixes for forgotten edge instances.
These will not be code issues. They’re analysis issues.
Code turns into treasured when it’s the solely place data lives.
and,
For many of software program historical past, treating code as sturdy was affordable.
We handled code as everlasting as a result of the labor to provide it was the bottleneck. Rewriting was costly. Re-validation was dangerous. Implementations collected which means over time. Construction, exams, feedback, bug fixes, and tribal data fused into one thing you realized to not disturb.
That made sense when manufacturing was the constraint.
When regeneration is simple, code stops being an asset and begins performing as a cache: a materialized view of understanding that’s helpful whereas present, disposable when stale.
“A materialized view of understanding that’s helpful whereas present, disposable when stale.” I feel which may have been the precise line that made it click on in my head.
Do you bear in mind the sysadmins?
I’m simply barely sufficiently old that my first job title was “System Administrator.” I used to be a teen, working on the college, with root on each machine within the days earlier than they realized they need to undoubtedly not try this.8
I lived by way of the shift from handcrafted server pets to immutable infrastructure cattle. I didn’t actually perceive what was taking place on the time, however I’ve contemplated it loads lately. I wrote this within the last chapter of Observability Engineering, 2nd version (now accessible, obtain right here!):
The shift from handcrafted servers to immutable infrastructure taught us that mutability is the sworn enemy of understanding. Any artifact that’s edited in place creates drift. Drift is what makes techniques inconceivable to take care of.
Our capacity to kill and regenerate infrastructure elements is the explanation we belief it. At Honeycomb, we kill the oldest Kafka node off by way of cron each Tuesday. That’s why we’re assured in our bootstrapping and balancing processes: all the things is repeatable, the information may be regenerated, the commitments dwell elsewhere.
The truth that we can’t regenerate our code in the identical manner is an indication that we don’t perceive it. We have no idea which commitments we’ve got made, we have no idea which dependencies will break. We discover them by breaking them, largely.
Consider all of the years of your working life you’ve wasted on painful migrations and rewrites. Consider changing load-bearing legacy code. Consider all of the strangler figs.
Strains of code have been doing an excessive amount of. The code has been the bundled up repository of developer intent, person expectations, implicit and specific behaviors, the one fossilized composite file we’ve got of bugs passed by. It’s an excessive amount of!
Strains of code will not be the best artifact to evaluate
And take a look at all of the domains which were uncared for because of the towering, all-consuming expense of sustaining and mutating strains of code. The place are the artifacts I can evaluate and talk about to know how our structure is evolving? The place are our structure artifacts, interval? What if we might talk about and converge on an structure diagram, and the code could possibly be regenerated from adjustments to the structure, as a substitute of the structure being kinda-sorta inferred from the code?
I’m not asserting that every one code will finally be AI-generated to spec, bypassing human understanding. The feasibility of this entire endeavor hangs on the query of what a spec is, or what a spec could possibly be. Anybody who has ever carried out a painful database migration ought to have realized some goddamn humility about our capacity to extract and formalize customers’ expectations in a replayable, automate-able manner.
However I feel that each step we are able to absorb that path can be good for us.
The instruments to do that don’t exist but, however most of the concepts do exist. Most come from operations and QA, two domains that software program engineering has traditionally been quite snobbish about.
These exams and methods will not be about testing for correctness or what ought to be taking place, they’re about observing and encoding what is taking place. Behavioral exams, characterization exams, seize/replay, visitors splitters. Observability (the nice variety).
Our brains weren’t constructed for validation
Having nondeterministic code in manufacturing is lastly forcing us to do the issues we must always have carried out all alongside. Instrumenting with traces. Assessments and evals in manufacturing. Manufacturing is just not what occurs after improvement is over, manufacturing is a stage of improvement.
Human brains are not good at validation. The nitpickiness, the repetition. That is the worst factor to be clinging to, y’all. There are such a lot of higher issues for us to wish to protect and assert for ourselves within the manufacturing and upkeep of software program. We’re by no means going to beat the machine with regards to validation—we are actually the weakest hyperlink!
My cash’s on people for very long time with regards to creativity, inspiration, leaps of logic, and a number of different issues, however PLEASE don’t relaxation your killer argument for people in software program on us being the most effective high quality gate. OMG. 🙈
Alright. I’m nearly carried out right here. Only one other thing.
Nondeterministic techniques would require extra engineering self-discipline, not much less
I feel what many engineers have discovered so alienating and terrifying concerning the final two years of AI discourse has been the best way so many distinguished AI voices seem like gleefully declaring that software program is now not an engineering downside. “SaaS is useless!” “Making AI nice at coding was the technique that unlocks all the things else”, and so forth. Even Adam Jacob, one in every of my dearest pals and somebody who is never incorrect about know-how, appears to anticipate a massacre of software program jobs.9
If 2025 was the yr of vibe coding, the place AI received nearly as good at producing strains of code because the median software program engineer, and the vary of attainable futures usually felt destabilizingly, impossibly extensive open, I really feel like 2026 is shaping as much as be a return to self-discipline.
The data in our heads is unavailable to AI till we encode it into the system, in any case. The returns on these investments can be huge and nonlinear. We’d argue that they at all times would have paid for themselves in the long term. However now each CEO in existence is chomping on the bit to get a few of these AI cookies, so let’s give it to them. Self-discipline first, cookies second.
That is our probability to convey our engineering values to the mainstream
The share of software program engineering groups that work briefly, quick suggestions loops (the cardinal signal of self-discipline in my e book) is, and at all times has been, appallingly small. 5 %, possibly? Undoubtedly lower than 10%. AI tooling brings this extra inside attain than ever earlier than. Or it may possibly. It might. The discontinuous returns on funding in engineering self-discipline are actual sufficient that it simply may occur.
I’m not fearful, not less than within the close to time period, about AI creating huge, discontinuous returns on funding within the absence of engineering self-discipline. (Many will strive, and it will likely be entertaining to observe.)
However worth is backed by sturdiness, not disposability, and I don’t see that altering. Bits are low-cost and quick and ruled by the principles of logic and language, however something with worth should finally resolve with bodily techniques: persistence on the one aspect, person expertise on the opposite.
Individuals don’t need to get up each day and log in to Slack and discover the buttons and menus all subtly moved round. Individuals don’t need monetary transactions that full more often than not. Determinism is just not going wherever, my pals.
AI is just not magic. That is nonetheless engineering. As Adam says, “it’s nonetheless know-how, and know-how wants technologists.” And I for one am wanting ahead to studying new and attention-grabbing engineering issues, reviewing totally different sorts of artifacts.
And by no means doing one other sticky, choosy, two yr lengthy API rewrite or strangler fig migration, ever, ever once more.
~charity
P.S. Due to everybody who learn a draft and gave me suggestions: Dave Williams, Chad Fowler, Adam Jacob, Mark Ferlatte, Austin Parker, Erwin van der Koogh.
