If you want high quality results, you need skilled developers who know their business. It's that simple.
I could stop writing at this point because that's all you need to know to understand why "software is breaking down".
Anyway, the problem is just that there were never enough skilled developers while the demand for software was ever growing. That's the reason why the software industry has always been crowded with unskilled amateurs doing grunt work. Amateurs were tolerated simply because of the lack of highly skilled developers: one good developer can easily replace 5 untalented code monkeys, but it's better to have 5 untalented code monkeys than 0 good developers so that at least something gets done. Programming languages like PHP or JavaScript lowered the bar, attracting even more, even less talented people. It really started going downhill during the dotcom bubble, well before cloud computing was a thing, and it never stopped going downhill.
In such an environment, if you want quality results, the amateur work requires supervision and strict quality gateways so that good code can be distilled from the bad. That is, code monkeys must be managed and supervised by more disciplined, more skilled, more talented developers who are actually capable of understanding and managing the complexity of software.
These days, however, everybody is being dumbed down by AI. Everybody even seems to enjoy being dumbed down by AI, even those who actually are (or rather, used to be) good developers. Instead of doing proper code reviews by a professional, an AI is consulted to do the review. Instead of planning a software architecture, people are vibe-coding. Instead of doing a simple change that actually works, an AI is asked to generate spaghetti code (and you don't recognize the spaghetti because you don't understand your architecture anymore). Good practices that served as safety net against low software quality are ignored because "AI doesn't need them".
Of course software is breaking down, now much faster than ever before! It is because we (as an industry) are moving at neck-breaking speed and have stopped thinking, even those few of us whose job is to keep the quality at least at an acceptable level.
Spaghetti Claude is killing quality faster than most can realize, and it shows already. Your amateur code monkey crowd has been replaced by even less talented, but much faster AI with a knack for convincing language. Your code monkey crowd is still there, but it is now instructing the AI to produce results the monkeys don't understand and push to production. Quality gateways have been dumbed down or simply removed to keep up with the speed.
It's a bad development that needs to stop.
> Companies loved Cloud because it allowed them to remove sysadmins and ops people from the equation.
um what? who? where?
Software was mostly always broken but it was hidden and invisible, now it’s visible because the cost of making it visible is so low
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
There is one root cause for all major software system issues: business doesn't give a shit.
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.
the 4 events (Php, emudhra , MS outage etc) were coincidental. Two of them were mostly theoretical . In the PHP case, despite the tremendous potential threat, the recorded damage has been relatively minimal. Everyone expected to see broad and severe compromises of PHP assets, akin to Y2K’s potential – and very little has happened.
A better narrative is that software quality has been very low for some time, and we are lucky that the threat actors have not compromised the assets as broadly as they could have been .
We have a great opportunity with AI to patch up the duct tape and popsicle sticks. Moreover, to realize that consolidating authority into central management with synchronous coordination is terribly brittle.
In other words, we can fix software by dismantling some of the dependencies.
Yeah, yeah, it's all misunderstood and the timeline is wrong and it's always been this way and and nitpick this and nitpick that but: I believe this is the way the "vibe" is shifting. The average person is going to guess that AI caused all the weird outages in the last couple weeks, corporate and Trump admin denials notwithstanding, and I suspect something like that is what the history books will record. If you are all in on this technology and surprised at these attitudes (or at the "blue wave" in the US, or at scandals "suddenly" dropping on Jensen Huang) it is a good time to look around.
Well there was this saying "Do One Thing and Do It Well", seems once again we are seeing the affects of ignoring that.
I’d argue this is a consequence of a lot that’s gone wrong in the industry. Maybe there was never a golden age, and I didn’t live through whatever there was, but there used to be real power in the craft of software engineering itself. Over time that power was eroded, co-opted, and sold off. There’s no single event to point to, just an accumulation that’s left us with top companies that operate like cults, people entering the field to chase status, and software that’s less the product of the craft and more a side-effect of dealmaking, politics, and greed. It isn’t true everywhere, but watching most of the talks given in the field now feels like touring the circles of hell. Everybody just seems blind now.
It's nice to say, "Oh we did it better in our day! You kids lack discipline!"
But look, the reality is we copy-pasted just as much slop we didn't really understand to get over the finish line back then as kids to today.
Deadlines were missed. There were bugs. Things broke. That's just life.
Now, do I wish we had TDD for everything? Yes. Do I wish there wasn't quite as much emphasis on AI? Also yes.
But there's a literal mountain of slop code that was written over the last 40+ years. Without AI, it sort of just sits there... people are afraid to touch it.
With AI, and I mean me using AI, I'm comfortable diving into a massive legacy code base and refactoring pretty much anything at will. And it's pretty cool when you stop looking at code as "I don't want to be the last one to touch it, because then I'll get blamed if it breaks."
And instead take the approach, "OK, without proper maintenance, this dies. How can I give it proper maintenance?" And look, if something breaks along the way, "Meh." I can fix it. Those old code bases were often just as buggy and duct-tapped as anything AI created... worse... years upon years of multiple developers doing patches. Convoluted AF.
I still like to think I have good discipline. I have a repo that has all my coding standards, and that's a good starting point for most of my projects. I weave in a bunch of rules as I go, things I learn, and that repo becomes the guide for the AI to do work on the project I'm working on. Then... when I'm not the one doing the work, it'll still be there to explain to the next person (or rather AI being managed by a person) why I did things, and what the goals were, and how shit works.
Most things that break... it's just because it wasn't documented in the first place. I find a lot of that... maybe they had discipline, and maybe the legacy systems that had the documentation were lost to time. Sure. Let's give them the benefit of the doubt. But... I'm guessing they did quite a few patches with just someone calling, "Hey Swanson, make the button blue, and make it say 2+2=7 to impress this client!" Right, so there's still a lot of that today too.
> At its worst, AI turns tech workers into “meat proxies” who spend their days massaging prompts and letting Claude figure out if the work is actually complete.
I am going to claim, AI is at its worst. Software companies are doing mass layoffs, they are decreasing the quality of software and reeking the profits, making sure only upper management (or worse, shareholders) are benefiting from software becoming so much cheaper and shittier.
And software workers are not loosing our jobs equally. Those that don‘t want to use AI are being fired much faster than those that do. And those that remain are de-skilling them selves, fast, letting AI do all the work for them.
I want to blame AI, and I want to blame capitalism and the profit motive for making sure that AI would inevitably cause as much damage as it possible could.
It's because amateurism has been hailed as the second coming of Christ.
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.
[flagged]
[flagged]
[flagged]
[flagged]
[flagged]
Every chud on here thinks they're Howard Roark or Dagny Taggert but they're really just Peter Keating with a CS degree.