If coding has been solved, why does software keep getting worse?

I actually relate to that. It used to be cool and exciting to update to see what new things are coming for free. I was just looking up what Fedora Workstation 45 might bring.

Updates on phones, TV's, cars and non-Linux operating systems on PC's/laptops are downright scary to me now. What will they add that I don't want? What more connectivity to the external world are they going to wire in?

MacOS lost everyone's trust by ruining the experience, but even before it happened that trying to resize a window makes it feel like life will be at 80 years-old, hunting a tiny invisible border, even before that there wasn't anything exciting.

What Microsoft I think did (and I can't prove it), before I moved off of Windows 11, was to bundle all changes in "required security updates." So you have no choice but to update (or go through special settings to turn it off, or just defer it), but when the machine comes back you have a new Welcome prompt to some new connectivity to something nefarious. AI features I never asked for, that's the most recent dark pattern here.

The people who notice broken or degraded behavior (devs and power users) and conceive of good designs are not in charge of what goes into the product. So you shouldn't expect it to get better, only to continuously change so that the imposters can point to a difference that they were responsible for, knowing that upper management also has no idea whether that difference was actually an improvement.

The solution is to gut your product org, replace management with leading engineers, and hire some of your most fanatic users. They don't need to do anything other than give their opinions, and use the product every day. Put them in a room with your top engineers, and the software will mysteriously get better.

All of this was obvious decades ago, but now everyone wants to have a do-nothing job at a tech company, and to help their friends get one too. The result is imposters everywhere; "imposter syndrome" was brought into the vernacular to normalize a lack of expertise. "No one knows what they are doing, it's okay to not know how to do your job". That's what your (product) manager tells themself in the mirror each morning. Turns out: skill predicts quality, and an org ships quality proportional to the skill of the decision makers.

One of my absolute favourite features on KDE Plasma with Wayland is the global setting to control what can steal focus. It works wonderfully, and I always miss it when I have to use my work mac or windows computers.

See here for docs, under "Focus stealing prevention" - https://docs.kde.org/trunk_kf6/en/kwin/kcontrol/windowbehavi...

This was true already before AI code generation, but AI code generation means the definition of “fast” has shifted like crazy. An experienced engineer can now build in an hour what would have taken them a week.

But it (right now) does nothing for the confidence about being correct - you still have to put in the extra time to ensure the software is correct to your desired degree of confidence.

Unfortunately for people who like their software to be correct (stable, performant, bug free, etc), it seems like way too many software developers right now are happy to take the gains of the former but ignore the tradeoffs of the latter.

(at the same time software quality for mainstream consumer goods like the kind of thing OP complains about in their post has been down the drain for a long time now, and it seems likely many of the examples they give are pre-AI)

I still don't understand how a full focus stealability debounce is not the norm. If I am in the middle of writing, or interacting with one UI bit in any way, no other app should be able to steal focus, full stop. Add an annoying popup if you want, make angry computer noises, flash icons, I don't care. 99.9, if not 100% of the time, it's completely unrelated to what I'm doing and can absolutely wait. While some OSs have something along these lines, they also give the tools to bypass it (I'm looking at you, Cisco AnyConnect! Being connected after clicking on connect is not an emergency!)

Imagine you're working in a terminal and an app decides to steal STDIN. Why do we accept that for a GUI?

There is a saying

Any idiot can build a bridge that stands, but it takes an engineer to build a bridge that barely stands

We found the limits of what it takes to make software stand, and what software paper cuts people are willing to deal with

My experiences as a user haven't really changed. Streamers fail to cast to TVs. Browsers are devices which reliably and efficiently propagate red console text and 500s from companies to you. I still see bluescreens on public touchscreens.

Uncle Bob nailed one reason why the industry isn't getting better: the growth of programmers is exponential, such that half of all programmers have less than n years experience (5?).

I offer two additional reasons:

Firstly, you hone your skills doing individual algorithms on a single thread, where it's OK to get it wrong and change it as many times as you like.

When you get a job, you don't even realise you're in a distributed system and the getter/setter model you practiced on is woefully inadequate for interacting with partner systems, cqrs, event-sourcing, auditability, idempotency or whatever else is required.

In short, 10 years of practicing writing for-loops and data-structures will not translate into building a system that customers can access via their phone and multiple tabs of a browser, at the same time as a database schema is being updated.

Secondly, while I don't think there is any realistic alternative to agile development, it seems that nontechnical POs have captured the software lifecycle. 'Focus on happy path only, for the MVP' is how you build buggy software. Good developers can learn that this will guarantee the need for a rewrite in the future, but POs never will.

It seems like the languages have been increasingly targeting the beginner segment (C++ -> Java -> JS -> Python), while the tasks have been getting more complicated (b2b distributed systems, 24/7 uptime, millions of users, resistance to hackers, machine learning, etc.)

Because the premise that coding has been solved is false. :-)

There was a brief stint of UX, ergonomics and HMI getting traction in enterprise, and, imo, the biggest technological achievements in consumer software has been in the realm of UX in twenty first century. But it lost its importance, I suppose, as you don’t need to make good software to make money off consumers.

Whatever capabilities AI gives to programmers in terms of speed of development, etc, doesn’t change the fundamental behavior —- commercial software is not developed for humans. It is developed for investors, markets, around operational needs, based on CEOs whims, developers’ personal itches, relying on approximation of human experience that gets regurgitated through layers of commercial processes of product managers, UX researchers (who, if present at all, often don’t get invited to the conversation until there are buttons to move in a GUI of an already existing product). Where human experience is considered, it’s from the perspective of our natural weaknesses with the goal to exploit them to maximize profits. Hence why 21st century tech gave us all the dark patterns, feeds, social media, LLM chatbots, etc.

Even when I talk to individual engineers who are committed to creating something good, wholesome, something that they can be proud of -— many think and reason about the problem in a way that sounds like they are trying to engineer human experience the same way one would engineer instructions for machines.

It will never get better, IMO. AI only exemplifies what already exists.

- URLs commonly auto-link to the things behind them, even including spaces and words.

- Pinch to zoom on the homepage causes the page to reload. Forcing you to lose your place/content.

- I sometimes cannot click to play videos on the feed. I can click through the comments and then click play on the player.

- Comments pasted from perfectly valid markdown render as whitespace deleted garbage

- Clicking "reply" then tapping in the box makes it disappear. I literally cannot see what I'm typing. I have to scroll to the bottom of the page to find it.

- After typing into the comment box the "comment" button to submit it is not visible

- Being a mod: The dropdown for selecting a removal rule will not let me scroll past what shows on the initial dropdown.

- Rare but critical interfaces like banning a user (or managing an existing ban). Essentially cannot be used on mobile.

- When typing responses to people as a mod, depending on the box sometimes I "lose" the comment button.

I come from sciences, where the problem of AI is more linked to AI-generated papers rather than coding. Again, the real underlying problem is the pressure to publish at all cost and the ranking grant system which rewards number of publication rather than quality.

I'm sure you could say the same of AI-generated images, sound or video used in advetising, or any field where AI generation offers a shortcut. The problem is always that you need to produce as much results as fast as possible and quality is not the objective. The problem is always the KPI.

The hard part of programming almost is never how ONE function or ONE class works. It's how they all interact in a much larger picture. You can try to mitigate this, but it's a pretty fundamental concept that software is big and just too large for an LLM context window.

Until that's solved, coding has not been 'solved' by '''AI'''. They're useful for greenfield stuff, but new software was always easier to smash out quickly than working on older code.

Plus, it's not like they're building understanding like a person does regardless, even if the context window was somehow enormous.

It was simpler, better, more stable, _and_ had better UX.

Complexity does not equal quality. In fact, it usually points to poor design. Programs used to be seen as utilities, which enabled the same kind of mentality you have to any specialised machinery: "Here's a thing that can make your life easier. Learn how to use it". Now programs try to be all-singing-all-dancing-all-the-time-changing.

Optimistically, I think we might just enter a new phase at some point, where businesses make very conscious decisions about what to invest in to differentiate. Like, everyone has support bots now. Where do we invest, absolutely stunning human support? Or is support not that key and we should invest into being the most reliable? The most enjoyable to use?

One can hope.

It is little appreciated how USB has regressed. If you have a full-size top-of-the-line desktop machine with plenty of I/O channels you have a huge number of USB 3 and USB C plugs and will have mostly a "just works" experience -- like you can plug in an external hard drive and not regret it. Try a laptop or a pint size machine (say a Mac Mini or a Dell Optiplex 1.5 l) and you'll discover there is no reliable USB 3 hub on the market Maybe you can plug in your keyboard and mouse, maybe, but plug in a USB DAC and a memory card reader and an external drive... "BONG!" "BONG!" "BONG!" Windows starts screaming that devices are dropping out and reattaching and God forbid there is a filesystem you care about on one of them. (MacOS is too smart for that shit, it just assumes the hub is crap and won't reconnect until you reboot)

Plug a cooler master keyboard into you dev workstation and you'll find it overloads the interrupt handling system and causes everything to be janky.

Probably the worst thing about Electron is that the #1 applications use it, instead of making a web application, is that they can't stand that you might be able to find the application and start it the way you start a usual application (or web page) or be able to find the window when you are using it or be able to close the application or move the application window like a normal application window or resize the application like a normal application window or that you might be able to see anything in the tray -- so applications like Slack automatically become crapplications by virtue of inhabiting your tray. It makes everything worse. It reminds me of the later 90's when every crapplet for your printer had to have a completely custom widget set and window chrome.

The smaller the org, the better the chances of having only reasonable levels of misalignment... but without taking on high risk, it's just better pat to work on a large, worse org. Frustrating.

Isn't that how it's gone before, though? People used to make beautiful furniture by hand and leave something of themselves in it. Now it comes out of a factory, nobody knows exactly which part they made, they just fit pieces together, and it isn't built to last. Software is at that same point: nobody knows exactly what they've made or how. They describe the problem, assume they've found the solution, ship it, and there is no undoing it. The sloppiness will keep compounding. But that is also the point where people start thinking much harder about how to make it good again. A cycle, I suppose.

Microsoft didn't need AI to make windows 11 as bad as it is.

The incentives are large companies are fundamentally not in align with making high quality software people actually enjoy interacting with.

If you're making a Linux distro, please don't do this. I will not watch your video. I was interested, and now I'm not.

I think that points do the solution. We should not make stuff more complex than we can the level of complexity at which we can make it reliable.

That's a different, equally big problem. Security mafia at every company will continue to rule everything and everyone. They do not have goals or constraints that are tied to productivity and user experience.

We are heading to a situation where the security teams are causing much more damage compared to the possible attack vectors. While this damage is real and certain, the damage due to attack vectors is only hypothetical.

Ofcourse, we do need security. But currently no one including CEO can dare to define how much security is needed. On top of that, regulators do their own share of damage, piling up regulations. No one takes any risk. They will ask you to tie yourself down until you can't move. Your mobility is not their problem.

Imo we know the tools (social, + technical) to make good software that works. But in the face of massive complexity, people just want the next feature, the next thing sales can use as a win

And yeah I agree with the other commenter here - I don't think this is AI. We had terrible software before, even declining quality.

If you look at the open source space and review the contribution of AI in it, you'd think that AI is barely able to create functional code and the people who peddle it are solely slop authors. More than that, you might think it barely exists, because there's simply vanishingly few PRs landing which are AI generated. It seems in open source projects, for some reason, AI is barely able to produce any useful code at all

But apparently for closed source proprietary code its like magic and you don't need to write any code anymore and it is a solved problem. Mhm. Totally willing to believe that

My suspicion is that a lot of proprietary software engineering has become purely performative. It no longer matters if the resulting product works, or has any quality, because its not about that. The system is being burnt down to extract wealth from it instead, as we create the illusion of software development as these companies are asset stripped. Line Must Go Up. There's no simply incentive to make a real product anymore, when the valuation of our economy and management compensation is built solely on hype instead of results

This is hilarious.

My other biggest pet peeve in this space is the annual iOS updates where Apple arbitrarily moves buttons back and forth between top and bottom of screen.

They really like to screw around with the photos app such that "show me my photos most recently taken in time order" is somehow different set of taps year to year.

You see flavors of this in most other apps/websites.

A product isn't necessarily designed by someone who cares about, or even understands, the problem at hand.

XFCE has worked more or less the same for me for the last 20 years.

Sure, nothing lasts forever, but XFCE has been rock solid and absolutely works as expected.

I've used it successfully on both FreeBSD and various Linux flavors.

Programming is going to be like ceramics or pottery: you can grab a nice set of bowls at IKEA for $10. We are doing the artisanal pottery that no one really wants or cares for.

It depends on whose perspective you consider the problem. An enterprise produces software for one reason only: make money out of it. And it works great!

if you are a paying customer, and if you can choose among a few different solutions, then you will get the good stuff. But for the rest...

1. Free apps? They just need to take ads in front of your eyes.

2. Software embedded in cars? You choose the car based on other merits, the software just needs to not by horrible.

3. Automated customare support? When was the last time you choose a fridge over another because of the quality of its customer support?

I don't necessarily believe in 10x devs, but there is a very clear output difference between various developers. During my career I've been both in a position where I was delivering much higher quality code at a similar pace to other coworkers and also mediocre code at a slower pace. Sometimes at the same time.

Now, AI itself is a force multiplier. Depending on the task, your setup, your skill level (both as a developer and with LLMs), the weather, the model and so on, it can range anywhere from actively hindering you, to solving the entire thing for you. Let's say that on average you get a 20% productivity boost.

If you take a 0.8x developer and give them a 1.2 force multiplier LLM, you get a 0.96x developer. Worse, the axis that has moved is speed, not quality.

All this to say that if you let a below average developer vibecode, you get a much higher volume of slop. You can make an agent create good code, but this developer didn't care before so why should they now?

*Note that this is from experience. I've started getting feature PRs from our devops team. It's been a very enlightening experience.

Expectations is neither about creation not use. "May" isn't a revolution outside of the historic calendar, so on both counts it's trivial to deny an ungrounded statement.

> So why does software keep getting worse across the board?

Because the premise on which the expectation is built is wrong?

Also plenty of the issues are prehistoric with all the past meat bag generations to blame, case in point: > Just then, the Slack window appeared, stole focus from Ghostty

So who stopped that huge fruit corpo from doing the very basics of managing user experience in the past few decades minus a few AI years?

None of this is to say that I think this is a good thing, or even that it's necessarily an accurate viewpoint. Considering who decides how much to spend on LLM products in companies that are potential customers for the ones saying "coding has been solved", I do genuinely think this is what they mean though. It's of course nonsense to actual developers, but we're not the ones who they're talking to when they say this.

I work in mediation and have recently seen a few cases where I’ve wondered if the participants were suffering from AI psychosis as related to their claims: where they’d constructed their legal cases hand-in-hand with an LLM and had become absolutely convinced despite a contestable set of facts.

People have always been subject to delusion, but in these cases, all documentation submitted was obviously created by chatbots.

It's just that complexity has skyrocketed compared to the past. The same goes for released software. In the old days, even small software could be competitive, but now the minimum level of complexity required to sell a program is completely different.

The best example of this is mobile games. Just look at the structure of early mobile games compared to modern games.

At the end of the day, fixing bugs, especially those bugs only happen in certain environments, is a very tedious and thankless task.

to the article: Yeah, it's different world out there. We need to filter ideas instead of focusing on more features, as lack of staggering revenue growth suggests it might be that more doesn't equal better. The stability of apps is getting worse lately. I couldn't pair my sony camera and it was stuck on pairing screen :(

It won’t change cause nobody cares to do anything other than complain, I don’t see developers quitting en masse from companies that refuse to pause feature churn and focus on quality. Why should they? They get a paycheck, everyone ships crap, the world moves on. The people making the frameworks and now even runtimes are of the same cloth, overworked and underfunded.

If we cared we’d treat software like real engineering. We don’t and therefore we’re quite cooked. Just be happy that airplanes aren’t as bad as your average CRUD. For someone who does care, look at the SQLite codebase, every project should be like that even if development cycles would be 3–10x longer, but that’s delusional to say out loud.

AI just revealed that - with slop being produced at increasing pace and test coverage and verification methods of things working properly across all states and inputs being nowhere to be found.

> They have raised upper management’s expectations for team output.

That is the worse part, it's not great at all dealing with this kind of expectations

IME this happens more often than people think. If you’re leading a team part of your job is to manage the expectations of those around you and explain your choices. If you do that well you can absolutely have quarters where you only pay down debt, it doesn’t require some huge attitude shift in the industry. Just explain why it’s the right thing and then do it.

A lot of this is about bureaucracy

I'm confident to say that right now, AI already does a better job at turning a well-specified requirement into working code than the average meatbag I've personally encountered.

It's still useless at many other things that make a complete Software Developer, but let's be real: Programming (requirements in, code out) is solved for the stuff I'm involved in.

This extends to any device which has software or firmware: banking websites, banking apps on mobile phones, car firmware, etc.

I find it very depressing, especially when I think of the people who design, develop and deploy these apps. We are talking about large companies and teams of people. Entire chains of well-paid people designed, looked at, developed, tested, and then accepted these apps. And yet they break in the most obvious ways, or fail to be usable, instead pestering us with pop-ups and useless drivel and forgetting their state at every point.

These problems are not subtle. To take a glaring example from my everyday life, in my car there are buttons for moving windows up and down. Sometimes when you press the button to move the window down, it will actually start moving up. We are talking about a simple button that moves a window. And seemingly everybody thinks this is fine?

I don't know what to do about this.

Making legacy code however is now very fast. So fast you can practically ship it straight to production.

Hint: mid-level engineers in tech hubs wouldn’t be getting 500K salaries if that was actually the case.

Name and shame! I'm in the market for a car. Which one should I avoid?

I mean, he has given the answer in the article: Because "coding has been solved" is from the perspective of upper management, not devs or users - and that cares about software quality and usability (as standalone metrics) about as much as the McDonald's board cares about nutrition value.

Euphoric, who?

Other than techbros and a small group of AI-delirious fanboys, no one is euphoric. Normal people in the industry are between anxious, scared, exhausted, resentful, resigned or just plain sad. People outside our industry? They see the enshittification clearly, and are most certainly the opposite of euphoric.

Now AI tests? Except not really. It claims to perform testing. It’s still up to us to review and remediate.

Back when I was using IRC from Emacs (with erc) I had written a safeguard in elisp against that. Haven't been on IRC in a while but this helped me prevent sending to the "group chat" (the IRC channel) a great many private infos.

Same for my real name for example: I had a filter where anything containing my actual name would be blocked.

I think a great many software where you "chat" with "groups of people" would benefit from having both default and configurable filters that catch obvious mistakes. Say you probably want a confirmation before attaching a private SSH key, or before sending a password in the clear (which could be filtered by blocking words matching the hash of the password), etc.

Not that it solves the fundamental problem TFA is talking about: nothing works.

But that is a given: that's why we need safeguards.

So taking it at face value is kinda part of the problem here.

The only way this can get better is by completely suffocating it off attention. It doesn't exist. It's not real.

It's glaringly obvious that poorly checked, AI-written, code is the culprit, I'm just wondering when companies will wake up.

Nobody gives a flying fuck about resiliency, good practices, security or any of that now that AI is there. All anyone cares about is pure output of features.

Any and all "productivity" gains attributed to AI efficiency are actually due to the complete disregard for any care or standard in the software industry in the past 2 years. Yeah you can output more shit when you don't give a fuck, big surprise, AI doesn't change anything here.

> My LG fridge started making weird sounds, so I tried to file a warranty claim, through a multi-step form with countless fields. It failed with a submission error at the very end. And I only found out because I looked at the JavaScript console.

Has that JavaScript code been written by AI? It may be more likely that it was written by humans. Well, the design of JavaScript really sucks, the language is both successful and horrible to use, in my opinion. And we have that issue across the board. Most programming languages really suck. C, for instance - that language is an abomination. But it is even more successful than JavaScript. Today I ran into the issue that I can not compile libpng; I keep on bailing out at it unable to find setjmp. About two months ago compiling it worked fine. I most likely did screw something up on my local system but ... the compiler is an idiot. It really does not tell me WHY it can not compile it anymore. Yes, it shows on the commandline that it assumes setjmp to exist but it can not find it. The error messages are pure and bogus. And the whole design of C cascades this horrible crap downwards. The languages that supposedly try to replace C also suck. Go? Yikes. Rust? Even more verbose. C++? Trying to replace C since decades. There is a ton of inertia.

The whole stack is utter gutter trash really. Everything is build up atop layers of complexity that in turn are not really well designed at all. Meanwhile more and more software is added. Now I need python due to meson, and meson is better than what came before. But it adds complexity. And has its own problems too. AI does not really fix anything here, it just AI slop spams on top of this. We kind of lost big at engineering. People are in general also not critical anymore. The design of most programming language shows that - including ruby, but ruby is barely used, so really the issue is mostly about C. The fact that C is so successful makes this even worse, since nothing replaces it. We just keep on adding more and more. Or we go the C++ way - and make it about 50x as complex. Or Rust - that syntax is even worse than C syntax which is also horrible. Of course even with great syntax and a great language, horrible software will be written. Companies want to offer a billion useless features. Many years ago I thought it was cool if my fridge tells me what I should order. Since the day of companies spying on people, I go back to simplicity at all times.

Let's have a look at a few rarely quoted examples from the last decade, shall we?

Just six years ago, a big company rolls out a line of new chips so good that geeks and technology experts all get ecstatic and can't stop churning endless raving reviews. Those chips are fast, small and consume little energy. On top of that, the big company reworks their entire OS (OS!), the whole suite of software it has for it, the developer suite with compilers and SDKs and god knows what else and also ensures that everything ever written for that OS for the old chips continues to work and it indeed does.

Then there's another big company that launched a file storage service around 20 years ago. Back then it was reliable and only gotten better over the years. They started offering their storage for a nanocent per gajibyte and twenty years of hard work allowed them to lower that cost to a picocent per gajibyte. They don't lose data, they are highly available, half of the internet stores their data at their servers.

And then there's a -- gasp! -- consortium of big companies (fools would reply to this with an XKCD standards strip) that works on improvements to a shared set of standards for 4G, one of the most widely used technology stacks in the world, agrees on it, calls it 5G and rolls it out across the world and the whole spectrum of hardware and software vendors in a manner that resembles replacing a wing of an aircraft mid-flight so that not a single pasta strand falls from the forks of the business class customers.

And here we have someone who thinks that a customer support page for his fridge (fridge!) thrown together by a low-paid second-grade developer in a third-world country is indicative of the whole industry decline.

"Nothing works", my hairy bum. Get real.

The issue is only partially within those who code. They get directions from those in charge, and they are just making idiotic decisions. And those who code, for some reason don't stand against those idiotic decisions in defense of a common sense and a great UX.

A blatant, exaggerated parallel would be: you are designing your kitchen and you've chosen a place for your washing machine such as that it will be unable to open its door. When inviting a professional, you expect them to correct such wrong decisions and explain to you that it won't work. But in programming, those who program, calling themselves "software engineers", would just place this washing machine where they're told, because it's "not my job". It's not a feature of an "engineer". It's being a coder lemming.