AI is great at following patterns. AI is great at writing tests. AI is great at doing work that humans would consider drudgery and then applying "enough" judgement to it.
The problem is that most software teams and most engineers are very, very bad at the thing that AI needs to succeed: technical writing. Documenting the patterns, the rules, the heuristics, the SOP, the judgement; developers could barely be bothered to write comments before (which in the AI age are free, infrastructure-less memory that is always "line-of-sight" for the agent and can be used to enrich with keywords).
It's not that AI is the problem, it's that we humans are good at resolving these constraints in the real world at a human pace. AI makes that pace impossible for a human to keep up as a trailing activity. Rather teams need to invest more in technical writing and producing the corpus that AI relies on to learn the operational constraints and rules.
As a result I get:
1) The enmity of my lead dev who prefers to do things more fast and loose.
2) Not promoted, due to the first reason and due to the fact that I don't have "impactful" metrics.
I'm not saying I'm perfect, there are definitely things I could have done better. But the fact still remains that the industry grossly undervalues maintenance and optimization that doesn't lead to easily measurable numbers that impact the bottom line.
That in turn is because it's hard to tell if SWEs are actually paying down critical debt or just wasting time. But that's the core problem, not that we're not good at it.
The good news is I can get AI agents to do this kind of work so I can now chase after metrics.
Typically these places are associated with compliance, audits and regulation with teeth. It might be adjacent to lawyers, in public institutions or weird consultancies. At least that's where I've found such work. Insurance and banking might be decent bets, and they sometimes also come with oddball tech stacks, perhaps mainframes, perhaps Smalltalk.
Maybe part of it is laziness but for sure part of is low morale and hopelessness.
That's fundamentally impossible though -- if the information isn't there, the model is just going to move toward the average and fill in the blanks.
On another note, I'm also not sure where I stand yet on the thing I see where software devs end up falling down the rabbit hole of building little mini software factories, with agents reviewing agents, coordinating agents and having agents cosplay human roles -- essentially 'orchestration porn'. I'm yet to dive into that rabbit hole (I likely will at some point, so I'm not judging), but from the outside it looks like you end up worsening your understanding of the system, while spending tokens unnecessarily and creating a closed-loop mini model collapse.
I've actually run into the situation at work where I've asked people whether the libraries they've made can do a particular thing and sometimes the answer has been "I don't know" (I'm talking just _features_, not even low-level architecture). At that point, something has gone wrong.
I'm starting to get really interested in "Okay, if human code review is fundamentally impossible given the volume of code, what can we do?". We have a tool that can essentially build tools for almost free, so I'm trying to approach it from that angle. Let's see what sticks.
Write less code. Reuse things that have already been written and thus were already reviewed and tested by someone else. Do not reinvent the wheel. KISS.
With AI everyone is implemented a dozen libraries from scratch in their project instead of using something someone else made. Why use a library for 2D geometry when ChatGPT can write one in 10 minutes?
More tokens, more money.
The fundamental problem is that current AI tools don't learn. They make the same mistakes over and over again, unless you give them explicit instructions to avoid those mistakes. Maybe we need to accept that all work is now done by new hires, who have read all the documentation but have no experience in anything. Or maybe AI tools will get better, and all that tedious documentation effort was just a waste of time.
> The fundamental problem is that current AI tools don't learn
They don't learn, but they are very, very good at searching. That is why writing things down is important, but so is getting that into some sort of agent accessible index.The same rules that you, an expert would apply, should be documented and used by an agent to apply those heuristics.
There are obviously some areas where there's spot judgement, deviations, and exceptions. But by and large, you have some heuristic that you use when evaluating output. Document it and give it to an agent.
Pathfinder lets you understand your product’s building blocks. So you and your team pilot your agents at the product level, not the code level.
It’s augmented product engineering: https://pathfinder.com.ai
I've seen it first hand. 70 people fired, 20 people left. The 20 that are left take on all the work that was done before, plus some extra, because every company now has a new AI product, obviously. AI agents make us so productive. Every review is a 30 second LGTM on 500 new lines of code. Confluence filling up with AI slop.
A few weeks back I saw, first hand, a DevOps lead getting ready to ship a big update to performance-critical product where Opus 5.5 suggested they completely turn off JIT everywhere because they were running into a HotSpot C2 optimizer bug that would make the first request after a restart fail with a 500. Actual fix was a one-line adjustment somewhere in a library.
People are scared of being replaced, so they need to appear as productive as possible.
A lot of devs still think their job is to produce code; it's actually to produce all of the guidance and structural scaffolding for the agents ("the harness") to guide its behavior and output.
A concrete example: I wrote a small library[0] (MIT, OSS) that improves how agents write unit and integration tests. This isn't product code, but this makes the agent better at writing the tests it uses to verify its work. (Tests become denser, more semantic, less context, type-checked setup, etc.). You can't expect an agent to do this by itself; the human needs to produce the scaffolding.
You have to stop thinking this way. It's our job to do what our management wants us to do, which is often to produce as much software at the lowest cost possible.
There are legitimate criticisms about AI use and how AI has changed the profession, but you have to learn which battles are worth fighting.
Personally, I was asking "but what's the use case" in every meeting. "Why would somebody pay for this". "Who's the customer". Right now the vibes are quite similar to back then.
Plus your documentation can often work very well alongside whatever skills you have created over time, because you basically have two sources it is drawing on telling it to do the same thing. I find it leads to less off book behavior.
I’ve always been perplexed by how people see AI as this creative tool or something to innovate with. That’s not how I see it at all. I see it as a device that can follow a template very well if you lay good tracks. They can archive and check hundreds of pieces of media way faster than I can. But I would never trust it to craft a story
The actual programming logic has certainly always been complex, but the integrations weren't so bad. You could learn your very small toolset quickly and focus on ideas. Now, you have an ultra-massive toolchain to come to terms with, made up of free software and "cloud" architecture that starts off cheap and gets expensive later on.
Dependencies have always been the problem, but that problem has expanded in every direction, at every layer, approaching our own limits of comprehension. AI has allowed us to catch up, temporarily, but given the collective penchant for upping the ante, I expect the real supernova is yet to come.
Part of it is the inclination of the developer to make the thing more robust. Part of it is lowering the barrier of entry, maybe to the point it's _too_ easy to submit a package. Part of it is bad decisions made by the package manager, like running arbitrary scripts.
Now it’s somehow guarantied that the volume of dirtied quickly prompted version of anything anyone ever cherished far exceed the scarce outcomes of the original.
In the past few years though, it’s been creeping into my domain too.
Even this needs a qualifier. Radiation exposure can cause bit flips. Certain aerospace applications must address this, and even some earth-bound applications at high altitude.
A quick AI-assisted search informs me that neither AMD nor Intel document any on-CPU error correction, though perhaps there is some. Apple currently has zero systems that even use ECC, which seems insane to me given they’re shipping systems with up to 512 GB of RAM.
This seems to be an issue that’s falling through the cracks again. I guess nothing will be done until there’s a critical failure due to a bit flip, and verifying that was the cause for a given problem is difficult.
On ECC, Apple needs to Think Different (tm). Maybe it should introduce actual “Pro” machines…
No matter what's trending worse there's always this thought terminating phantom law of conservation of everything. The fact that something is not an entirely new bespoke phenomenon always turns into denial that it could be happening more often or in a newly qualitatively worse way.
I think only one of those is true. It takes a lot of effort to get quality architecture and not-function-soup code (at least in Python) from LLMs. I can't imagine the pile of crap code bases these software factory type solutions are producing. Well, you can see a lot of them on GitHub I guess, so no need to imagine.
Further, one of the negative impacts I've seen from being able to go a lot of faster is that it translates to product teams being able to ship faster which is not always better. We've lost the "back pressure" we used to have in software development which forced product teams to consider, then consider again, then consider again as each new sprint requires reevaluating priorities. This resulted in a lot of things not getting built that should have never been built.
Now we are building all-the-things and I think that's only better in some cases. I think it's proving worse in most other cases.
The analogous situation is brewing. The depth and complexity of our computational infrastructure is increasing, and the impact of an incident is less and less likely to be contained solely to the affected system. Eg, a router replacement goes awry, and the entirety of the world’s aviation industry is broken for weeks.
Intentionality isn’t necessary: this is a systemic problem.
The harsh reality is that some people/systems are adapting just fine to the new way of doing things, others are making a mess of things by rushing via vibe coding and not checking the work (either by choice or by circumstance at work). The results won't be (and shouldn't be expected to be) linear.
The 2010s brought on a very groupthinky dynamic to software dev. This led to a culture where the majority of developers just ask "what is everyone else doing." Now that we're past the blog era of development, that shared reality appears to be breaking down. Now the answer really is "whatever makes sense for/to you," but I think (anecdotally) that's freaking a lot of people and teams out.
For the first time in a long time, a "best practice" doesn't really exist.
I feel this piece is either more alarmist than it deserves to be, or it is late to the party.
It uses various incidents in 2026 to prove a point while dismissing those that did take place in the decade or so previous. For example, heartbleed, the log4j RCE, Rails' mass assignment DOS, Cloudflare updating a WAF rule and breaking the internet, Atlassian deleting almost 1000 of its customers' accounts and data, the Ashley Madison breach, Crowdstrike bricking their customers computers, Okta getting owned multiple times, etc.
My own point is that software became like this when we started becoming pragmatic. Nothing to do with AI or management really, we just realised, especially with web tech, that you can release something and then fix it. In the old age of getting CDs or floppies printed and distributed, that was not even remotely feasible. A similar incident in the 90s would involve a product recall or a way to get updated media from a retailer with the fix. Very expensive.
Standards have dropped and continue to do so, because we can also fix fast. It's not suddenly breaking down. If anything, it's just too centralised.
Some things happened. AI is also happening, therefore AI is to blame (in the way that some people really believe a problem isn't a problem unless you test for it) and here's a lesson about organizational coherence or something.
These essays are the real AI slop of 2026. Not authored by AI, but always trying to get attention by tangentially being related to AI and getting the anxious upvotes of the "can I turn back the clock?" crowd. And there's a humorous commonality to all of these pieces that they all start with some sort of "don't think I'm not with it. I'm with it! I hand slung an LLM off the shoulder of Orion. I watched C-beams glitter in the dark near the Tannhäuser Gate." call to authority, then pivoting to the "everything has gone to shit" spiel.
We've always had a tenuously connected, barely operated network of systems. We've always had bugs and engineers doing shitty things. Every organization goes through periods of upheaval where all of the institutional knowledge is invalidated or discarded regardless.
None of this is new.
In my view, however, what is more likely to happen soon is usage of LLM to transform various parts of code into the form with much more clearly defined interfaces/rules/boundaries that can be essentially proven to work correctly. That in turn (in my view) will enable much more robust systems.
The security issue motivated all Bitrise customers rotating their secrets. this was a big deal for mobile deployments but didn't get much attention on HN..
The problem software engineers are facing is that now that software is ubiquitous, almost everything needs to be 100% reliable (or close to it). This is coming into conflict with the move fast and break stuff everything needs to be done this quarter at minimal cost mentality.
Hence why we are at the breaking point.
Problem is I’ve had 5x more incidents. AI is operating at 10x the speed of a human so even though it’s failing less, it’s causing more incidents per month.
I wonder if people are ready for this kind of paradox where using AI may be safer and faster but less reliable for “human time”.
Perhaps no one is intentionally destroying anything in this case, but malicious compliance and simple negligence can go a long way when it comes to disruption of complex systems. Destroying a sewing machine requires actual violence. An air traffic control system is an abstract concept. You don't need to touch it to break it.
The one compelling part is that now we might be forced to pay for some of the rickety towers that we've erected because AI has made exploits pretty cheap to try.
Like before, individuals in an organization had various interests, motivations, connections, knowledge, context, that allowed our organizational brain to function properly. Now, everyone is (or will be in the future) a meat proxy, isolated, and disengaged which produces an organization with neurons but no neural connections: apparently healthy but, as the author put it, decoherent.
I remember the first time I installed Linux in the early 2000s and was and owned within 5 minutes of putting it on the Internet. Desktop computers of any OS crashed regularly. Servers crashed and needed total rebuilds.
If anything software is way more reliable than it appears because the scale of computers and software is thousands of times larger than it was 20 years ago. More things can fail because there are just more things.
This wasn't always the case, by the way. It started with the "dot-com" mania and VC investment in the late 1990s. Before that, a programming job paid decently well but it was on the level of other cost-center professional jobs such as accounting. A comfortable living, but nothing extravagant.
This seems a bit myopic. Or naive. Open Source "happened" a lot longer than 10 years ago. Microsoft didn't shit itself about Linux just 10 bare years ago. And it's not like prior to 10 years ago, the narrow focus of npm world wasn't cobbling web sites together with bits and pieces garnered from wherever.
That said...
> But AI is both a cause and a symptom
This I agree with 100%. The rise of AI and necessity of AI to continue to make progress is a massive indictment against an industry that prioritized more features and uptime over solid first principles for years, taking out promisory note after note in complexity, in hopes that the stuff papered over would quietly just fade away.
On the other hand software is improving dramatically at a systemic level, even without safe system languages arriving on the horizon.
It reminds me when I first started work on a codebase with proper unit tests: I thought I could ship whatever and the tests would catch it. That was incorrect; while unit tests are a guardrail, I still had to properly test my code.
Similarly, people need to learn how to use AI and make sure they don't introduce bugs or slop into the codebase.
But this brings up a larger point for me: most people are grieving the loss of what their jobs used to be, and denial is a core phase of grief.
I went through it too. I tried to find ways to say AI was silly or wouldn't work. But now it's inescapably here and we need to work in the new paradigm. There are plenty of valid criticisms, but it's already very good, it's getting better, and you have to learn how to use it as best you can.
Which means all critical software has bugs!
There's also more of it! Even more once you finish reading this sentence. If security incidents scale sublinearly vs the growth of critical software, we should be proud.
Crappy work is not universal either. There are engineers out there, guiding agents diligently, doing a good job. Never letting an agent go wild unattended, writing the same code they'd have written themselves, but with more tests and more better assurances and more docs and better infra and and and.
The problem that leads to blog posts like this is that good, diligent work, like critical software that does its job, are invisible.
Because no one notices a building that's not on fire. They just walk right by.
That's called outsourcing, which inevitably enables "vibe" effect of the coding: Your AI goes out of its constraints and does totally irrelevant shit you didn't ask for or does something barely passable you could approve, without knowing further consequences because you outsourced your thinking and control over the project.
To try to find a remedy for this shortcoming, they invented "skills", which totally negates the purpose of an AI (LLMs, genAI, whatever you call it to describe the current tech) IMHO.
It's also funny reading these comments. Most say "well, it was already broken" and they continue trusting AI more. Well, AI is not exempt from this "brokenness".
LMAO. They can't lose something they never had in the first place.
This article has other pearls like this:
> Reddit and Bluesky speculated that even MSFT engineers had no real handle on the complexity of this outage.
Like, with all due respect, what the fuck do they know?
Also this:
>It’s the software that controls your flights, your banking, your petrol pumps, your TV, your payroll.
Dude, how are you gonna sneak TV software into the same sentence as flights and banking? :D
This is not a serious article, and I don't recommend reading it. But to finish on a positive note, since I've already (regretfully) read it, here's a sentence I like:
> This is the real threat: a scenario where nothing in the system is done with intent, and nobody in the system has control. We generate complexity faster than we can tame it.
I would just add that this was the case long before AI. And also, just as AI generates complexity at such a great pace, it can just as easily help you fix it and fight that complexity.
There's a lot of slop, and it will almost certainly grow quicker than non-slop, but there is a big opportunity for those of us who still work at the bottom to make the pillars more solid, and take on re-engineering projects that would be infeasible otherwise.
Case in point: Before Claude a port of my compiler to a new architecture might take anywhere from months to a year. After AI, now that there are multiple backends as examples and an even larger--massive even--test suite, this can take days or less. It took Claude about 3 days to come up with an arm64 backend for Virgil (around April time frame). Then in August it took just 3 hours to build a complete RiscV backend. Both of them pass the entire test suite. And they shook out other bugs elsewhere. Overall, more targets, and more robust.
Things can have rocket boosters, you just gotta know where to place them.
This is classic surveillance/detection bias: https://healthjournalism.org/glossary-terms/surveillance-bia...
It’s basically free to black/grey/whitehat penetration test anything and everything without having to even know what ghidra or metasploit so everything gets penetrated
Empirically, we can observe the breaking effects of this broken thinking. Code quality goes down, and apps go from being 99% to 95% reliable. But that's not a big deal, they say, that's good enough... But when the quality of all the building blocks further down get degraded in the same way, you can't keep track of which parts are broken, and which parts are dependable, and the whole thing comes crumbling down.
People keep saying, "I can build an app with AI, therefore we can build everything with AI." This article talks about some potential anecdotes that could help to show that doesn't work.
The problem for LLMs is less formal and way more wicked. We don't have any good theory of software reliability. At all. All the reliability we have is artisanal and designed ad-hock.
We prove properties of programs all the time, that's what a type system is for.
Can we prove all properties about our program that we're interested in? Maybe, maybe not. But Rice's theorem is not the tool for that argument.
Of course the point is not whether we can now do this with AI, but whether AI can help us get the same quality we used to get, faster.
Also, consider that it should rarely be the goal to enumerate and judge every possible behavior of a program, with exceptions for life-saving or otherwise critical software.
There isn't a software system in the world for which we can't predict the failure modes and make solutions for. You simply ask two questions: 1) "How can I tell for sure this thing is working?", 2) "If it doesn't work, how do I fix it so it does work?". You might not know the answers at first, and that's fine. The business's job is to ask the questions, do all the work to figure out the answers, and then test & implement the answers. If the business does this, they prevent most of the failures, and have a quick deterministic solution for when eventual failure happens. If the business doesn't do these things, they are choosing to let it fail in an unpredictable and likely very expensive way (they don't give a shit).
This process has a bunch of names. Failure Mode and Effects Analysis, Business Continuity Planning, Risk Management, etc. No matter how you slice it, it's the same basic work: find out what could go wrong (at a high level) and have a plan to fix it when it does. It's not always easy, but you can always figure out some kind of plan that works.
For all the security and reliability issues we've seen lately, there are known methods to either prevent those problems or fix them quickly. The incidents aren't happening because something new is going on. They're happening because businesses stopped giving a shit a long time ago, and the chickens are coming home to roost.
Leftpad, mentioned in TFA, is a case in point: not because of leftpad itself but because of all those defending leftpadism.
"People can't write a proper leftpad".
Yeah, well... If a dev cannot write a proper leftpad, then it should never have been a dev in the first place.
Someone who cannot write leftpad is not qualified to use leftpad as a dependency (and, no, leftpad is neither the Linux kernel nor a cryptographic libray: it's fucking leftpad, which is the entire point).
We've had "devs" whose only qualification was writing glorified "punch the monkey" ads in JavaScript: the JavaScript surveillance/ad complex. Devs who only ever knew the mono-threaded JavaScript ecosystem and suffered from heavy leftpadism.
And those very same surveillance/ad complex bros are now generating countless crap with LLMs, in languages they don't understand.
They're just mediocre.
That's what happened: the veneration of mediocrity.
Because of this, battle-scars from the rough edges of software are seen as part of software-competence, not as a failure of industry. Novices get met with 'you're holding it wrong', but at the same time veterans lose the plot and spend most their time doing technical onanism, or worse, fighting meaningless complexity.
Until the stack exceeds any individuals understanding, and the cracks start to show. Leaky abstraction upon leaky abstraction upon layers and layers of ducttape, under the guise of HA, distributed system mantras, robustness, you name it.
Every part needing babysitting because every part is half the solution to half of your problem, but admitting that is seen as a skill issue.
Yes my DB dies because it caches stuff and (under obscure circumstances) never frees it: 'thats just MySql, deal with it', yes of course my frontend framework needs to be kept up to date every week because everyone is evalling strings all the time, 'don't you sanitize your input?', multiplied by every layer of the stack.
Don't you let your static analysis automatically merge security PRs so you can stay on top of this giant heap of string evals? No? That's best practice man!
1. Consolidating internet-dependent projects to a few winning cloud vendors and a dozen winning SaaS providers, made all of those project have coincident failure points. Which is great for corporate accountability ("it's Amazon's issue, not ours!") but bad for end users ("shit, EVERYTHING is down today")
2. The movement to migrate fat local-first projects towards thin internet-dependent or server-hosted ones made almost all software share those same coincident failure paths. This was good for entrenching a subscription business model and brought some end user conveniences, but meant everything being down meant everything being down.
3. Anxious and lazy dependency-first development culture ("you could never write that as well as some github rando") meant projects now had an order of magnitude more contributors but only reviewed and owned code for a surface level, making all these projects extremely vulnerable to supply chain failures and subject to constant maintenance churn.
4. Employment and team tenure continually fell so that most projects no longer have experienced owners and instead just temporary custodians.
You can find the seeds of many those problems in the 1990's and earlier and you can even argue that some of them were inevitable (and even worthwhile) destinations for the industry as it evolved without an engineering guild to slow it down and insist on rigor or evidenced safety.
But anybody who's been around for a few decades can attest to how these risky patterns rapidly grew into norms over the past 20 years and shifted the industry from one where any given software had some idiosyncratic bugs that users could learn to work around to one where all software had lots of bugs, many of them correlated across apps, whete failures would wash through and shut down (or make vulnerable) whole industries for hours or days, with effecrively nobody in particular to hold to account for any of it.
Software has never been in a pristine "golden age", but the last 20 years built almost everything on one giant, shared house of cards that's now teetering on the brink of collapse. Better or wose, it's indisputably different than it was before.
The PHP2Shell bug existed more than 15 years ago, spanning releases as early as 5.x. There was no AI coding back then. So it's very hard to blame AI. There was a coding mistake, and AI found it in 2026. Probably a good thing before a malicious party does the same.
OSS definitely flourished way before 10-15 years ago. I'm not sure what the author suggests as "knowing the details". Should we all rebuild our own web scripting language to know "all the details": e.g. PHP? Probably not practical. A line has to be drawn on where your knowledge and expertise stop. THe line can be vague and consistently changing based on needs. But there will always be a line. We will always stand on shoulders of of our predecessors one way or another
I understand the author's trying to say the overall situation is unstable and trending negative but I am not sure the writing's logical flow is holding up very well.
A better way to put it is we've written a lot of code, and a lot of it had bugs hiding in plain sight. AI made the whole bill come due at once. And will this AI code explosion create another bill we won't know about until 20 years later? Who knows.
I find the arguments about decoherence and the sort of snowball-of-complexity more compelling than this timeline.