The next article initially appeared on Charity Majors’s Substack and is being reposted right here with the creator’s permission.
A couple of days again I wrote a bit referred to as “AI fans are in a race towards time, AI skeptics are in a race towards entropy.”
I’ve notes on an entire pile of AI-related subjects that I’d prefer to cowl in depth: AI mandates, communication norms, code assessment, AI artwork, and extra. Sadly, I acquired 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.
By some means, a subset of readers got here away believing I used to be telling everybody to ditch code assessment and push their shittiest code straight into manufacturing with out studying it, proper now, tout suite.1
That isn’t what I’m doing. That isn’t 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 that AI-generated code was slop and may all the time 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 in a position to generate code that’s roughly nearly as good as that of the median software program engineer, no less than for frequent patterns, and far sooner and extra cheaply. I got here out of a ebook gap and realized this in January, and over the primary few months of 2026, it appeared like everybody round me was having an analogous 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) grew to become 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 basic goal usability on the finish of the yr.
That’s what the fans have been attempting to inform us final yr. Not solely “that is coming”, however “that is coming sooner than you assume.”
Because it seems, they have been proper.
It was cheap to be skeptical the primary time
As you could know, I come from the reliability aspect of the home. The praise I’ll pay to myself and my folks 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, due to 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 folks is that we generally wrestle to simply accept that progress is actual, that the continued existence of bugs and edge instances doesn’t diminish the truth that big swaths of downside area do get more-or-less solved over time, to the purpose they are often taken without any consideration by most individuals.3
The pace at which code went from complete crap to “ah rattling, that’s not dangerous” is what I’ve behind my thoughts, as fans 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 consider it after I see it” was forgivable the primary time, however a lot much less so the second time. That is what it feels prefer 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 beneath no obligation to affix me there. However there are approach too many sweeping statements on the market proper now about “it was by no means X”—“it was all the time 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 have been turned the wrong way up. As a substitute of being very arduous, time-consuming, and costly to generate code, it grew to become 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 approach folks have realized to know software program is by writing the code. When you’ve achieved some mastery, studying and discussing code will get you many of the approach there. (I would argue that software program engineers have all the time relied far too closely on the code as a substitute of sensemaking the system by means of observability.)
“The true product of a software program crew is shared understanding”
Many nice software program engineers maintain that true product of each (good) software program engineering crew has all the time been a shared understanding of the software program we personal. That it will get saved as cache state in our fragile little meat brains, ceaselessly flushed to disk, deployed to manufacturing, dedicated to github, however our minds are the place which means has all the time lived.
Is it any surprise that software program has all the time 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 folks’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 features of the software program growth mannequin. We’re forgetful, distractible, impatient. We’re dangerous 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 rationalization. To us, it’s clear that the true product of each (good) software program engineering crew is manufacturing.
Solely prod is prod. Check in prod, or dwell a lie.
(That is all backstory. I get to the purpose, I promise.)
Seems, that is an engineering downside in spite of everything
We issued our AI mandate final August.5 I had seen sufficient to know that this was occurring, and it was time to do the accountable factor. Honeycomb is a devtools firm, and folks come to us to assist with arduous issues on the forefront of expertise. 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.
For those who don’t know what I’m speaking about, it’s best to truthfully 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 speak about manufacturing sufficient.
Once 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 acquired excited.
This has all occurred earlier than, and this can all occur once more
I’m going to provide 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 standard premise: by no means repair a working factor. Change it.
AI pushes this premise past infrastructure and into software code itself. When rewriting is affordable, enhancing in place turns into dangerous. Mutation accumulates entropy. Alternative resets it.
One other favourite: “The Deletion Check.”
Right here’s a easy take a look at you’ll be able to apply to any software program system you’re employed on:
Think about deleting the whole implementation.
Most engineers expertise deletion as existential. Code feels just like the factor. It’s what we write, assessment, model, deploy, and debug. Shedding it looks like dropping the system itself.
When folks say, “We are able to’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 all the time maintain.
- We don’t know find out how to inform if a brand new model is right.
- We don’t know which bugs are intentional fixes for forgotten edge instances.
These are usually not code issues. They’re analysis issues.
Code turns into valuable when it’s the solely place information lives.
and,
For many of software program historical past, treating code as sturdy was cheap.
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 gathered which means over time. Construction, assessments, feedback, bug fixes, and tribal information 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 appearing 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 keep 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 means of the shift from handcrafted server pets to immutable infrastructure cattle. I didn’t actually perceive what was occurring on the time, however I’ve contemplated it quite a bit in recent times. I wrote this within the closing 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 unattainable to keep up.
Our potential 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: every part is repeatable, the info could be regenerated, the commitments dwell elsewhere.
The truth that we can’t regenerate our code in the identical approach is an indication that we don’t perceive it. We have no idea which commitments we’ve made, we have no idea which dependencies will break. We discover them by breaking them, principally.
Consider all of the years of your working life you might have 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, consumer expectations, implicit and specific behaviors, the one fossilized composite report we’ve of bugs passed by. It’s an excessive amount of!
Strains of code are usually not the best artifact to assessment
And have a look at all of the domains which have been uncared for as a result of towering, all-consuming expense of sustaining and mutating traces of code. The place are the artifacts I can assessment and focus on to know how our structure is evolving? The place are our structure artifacts, interval? What if we might focus on and converge on an structure diagram, and the code may very well 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 complete endeavor hangs on the query of what a spec is, or what a spec may very well be. Anybody who has ever finished a painful database migration ought to have realized some goddamn humility about our potential to extract and formalize customers’ expectations in a replayable, automate-able approach.
However I feel that each step we are able to absorb that course 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 reasonably snobbish about.
These assessments and strategies are usually not about testing for correctness or what ought to be occurring, they’re about observing and encoding what is occurring. Behavioral assessments, characterization assessments, seize/replay, visitors splitters. Observability (the great form).
Our brains weren’t constructed for validation
Having nondeterministic code in manufacturing is lastly forcing us to do the issues we must always have finished all alongside. Instrumenting with traces. Exams and evals in manufacturing. Manufacturing isn’t what occurs after growth is over, manufacturing is a stage of growth.
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 in the case of validation—we are actually the weakest hyperlink!
My cash’s on people for an excellent very long time in the case of creativity, inspiration, leaps of logic, and a variety 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 virtually finished 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 in regards to the final two years of AI discourse has been the way in which 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 every part else”, and so forth. Even Adam Jacob, one among my dearest mates and somebody who isn’t fallacious about expertise, appears to anticipate a massacre of software program jobs.9
If 2025 was the yr of vibe coding, the place AI acquired nearly as good at producing traces of code because the median software program engineer, and the vary of doable futures usually felt destabilizingly, impossibly large open, I really feel like 2026 is shaping as much as be a return to self-discipline.
The information in our heads is unavailable to AI till we encode it into the system, in spite of everything. The returns on these investments can be huge and nonlinear. We’d argue that they all the time 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 in brief, quick suggestions loops (the cardinal signal of self-discipline in my ebook) is, and all the time has been, appallingly small. 5 p.c, perhaps? Positively lower than 10%. AI tooling brings this extra inside attain than ever earlier than. Or it will possibly. It might. The discontinuous returns on funding in engineering self-discipline are actual sufficient that it simply may occur.
I’m not anxious, no 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 will probably be entertaining to look at.)
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 in the end resolve with bodily techniques: persistence on the one aspect, consumer expertise on the opposite.
Folks don’t need to get up day by day and log in to Slack and discover the buttons and menus all subtly moved round. Folks don’t need monetary transactions that full more often than not. Determinism isn’t going anyplace, my mates.
AI isn’t magic. That is nonetheless engineering. As Adam says, “it’s nonetheless expertise, and expertise 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. Because of everybody who learn a draft and gave me suggestions: Dave Williams, Chad Fowler, Adam Jacob, Mark Ferlatte, Austin Parker, Erwin van der Koogh.
