I think in this text, details like the timeline are simplified a bit too much. But I agree with the general tendency described.
There was never a time where software was perfect, but the accelerating cadence of serious, widespread incidents with real-world effects seems real.


At one point around ten years ago, I was in a software development training course talking about test driven development. We did a roundtable exercise where each developer took turns writing tests and then someone else wrote code to try to get the test to pass.
One of the developers in the exercise wrote code that was obviously incorrect to pass one of the rounds, but all of the tests passed. After that code was written, everyone basically became stumped as to how to proceed, and we largely ended up talking about how the “coach” needed to “catch his flight” soon and he exited the exercise early.
I must admit I have not read 100% or even 50% of the vibe-coded crap I produce in my latest slopware, but I have a distinct feeling it fits in the category of the type of code written by this developer at the roundtable exercise. It’s not wrong in a quickly provable way, but it ain’t fucking right in a fundamental way.
When I was a hands-on developer (around 5 years ago+ at this point as I did a stint in management / design type roles), I used to build my way up to problems. My proposals and documents attempted to show what I was solving and what I was not, cleanly and clearly. You could read a document or code of mine and I would try to make it obvious what was missing. AI works the exact opposite way, it builds a mountain of bullshit that looks plausibly like it could be solving the whole problem, and it’s up to you to try to sift through that and figure out what is missing.
I’ve encountered innumerable issues in the software I slop together these days, and I have to say I think this thing does a good enough impression of working software that many people will not find these problems. There are a variety of different ways that things are incorrect when you interact with the software that if I did actually read the entirety of the codebases, I do not believe that the basic structure would even make sense.
Just for kicks, I read through parts of one of my larger slopjects tonight, and it looked like a mess of tiny functions with no coherent structure binding them, which pretty much confirms my suspicions.
I understand too that a lot of corporate software was like this anyway, so who knows, maybe we’re trading like for like or something. But there used to be at least one person who knew how shit worked. I’m not sure that person exists anymore.
I fucking hate doing the latter. If you do it right the first time, you’ll have a solid foundation and won’t have to live in a patchwork house.
I think metrics like code coverage are a big part of the problem where devs are encouraged to stop short of fully testing something or write low-quality tests that prove nothing to satisfy the metric.
The classic simple example is a divide function that takes a dividend and divisor and returns a quotient. One test that passes 6 and 3 and asserts 2 yields 100% code coverage, but what what about divide by zero errors? Does it work with negative numbers? Etc., etc. You’re definitely not done with tests, despite the metric saying you are, and a slop generator (human or AI) could certainly write a fundamentally broken implementation that passes the tests.
Now combine that with a tendency to focus on unit tests that test the system in a manner that hardly reflects how it works in production, and you have a system that passes all the tests, yet doesn’t actually work.
This is generally solvable via mutation testing. Sadly, almost no developer knows what mutation testing even is.
Yes! I’ve been trying to put my finger on what the problem with AI generated code is and it’s coherence!
@aesthelete @technology Insightful.