hckrnws

> We’ve reached a point where an update to macOS — or to any app I rely on, really — is a source of dread rather than excitement. I now expect the new version to be 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 answer, of course, is that the taste-making apparatus inside the typical tech company is now entirely imposters (non-technical, non-power-users), who continue to LARP as visionaries.

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.

Incentives.

People get promoted, get bonuses based on some shiny new tool they developed. Every year, they create something 'new', claim lots of features. Their managers/directors/VPs also encourage this because they need some 'winning' and 'automation' slides to brag about. Nothing gets solved. In fact, things get worse. The new tool and old tool and oldest tool all coexist with 20 other tools developed for the exact same thing in a different org. Each org (SVP reporting to CEO) is MASSIVE and everybody wants headcount and success stories. All these things will be happening at the same time. Those who are capable of making the biggest mess get the biggest pay and bonus, they get promoted and they move nearly year 1 - 2 years, within the same company or to another. Repeat. The ICs (individual contributors) who have values and explain why this is a bad idea are usually moved to Support or Ops roles or migration projects from old to new.

I've seen perfectly working systems continuously being replaced with worse and worse tools. Most of the new tools require a lot of people from several departments, just a guy who understands business and develops a perfectly working PHP/CRUD is a no-no. It has to be replaced with a complex monster with react, apis, mongo crap. And on kubernetes. Hybrid cloud.

> I opened Slack on macOS, the icon kept bouncing in the dock for a few seconds. I got impatient, switched to Ghostty, and started typing. Just then, the Slack window appeared, stole focus from Ghostty and the git pull command was sent to the group chat.

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...

As crazy as it sounds, code quality != software quality.

It turns out that the lower the barrier to creating "high quality" code is, the worse the software is on average.

Who remembers the Photoshop lens flare?

It's not that the effect sucked - it did lens flare perfectly. But who used it sucked.

Instagram and the Nashville filter - "we're all photographers now"

Code quality not equaling software quality gets at the fun part of the modern AI-labor debate. Where does talent and efficacy really reside in terms of software? Surely not in the (apparently unworthy?) mind of a human? Surely it can be extracted, distilled, automated – liberated! - unto a reactive web interface for some middle manager to invoke (at some expense to some account this folk loses zero sleep over), because it is after all this flimsy, transferrable - not worthless! Not worthless! I have a stock portfolio to maintain for God's sake. But mine. Nonetheless.

Code quality doesn't equal software quality.

We are not using LLMs to solve the issues. We are using LLMs for speed. Like we were using VC funded speedruns for "speed". Quality was never even in the picture. We just added LLMs to the current setup for speed. Neither the structures, architectures or decision makings changed. We just added another thing.

I keep thinking about another thing as well. Software development might be the only place were stability is punished. If your software works swellingly well, there is less people needed. You'll lose your job when the software is stable. So you either need a new project or the software needs to be crappy enough. And the companies don't give a damn about you.

Keep in mind we did have WhatsApp created with just 32 engineers until facebook bought it. Lichess.org has 2 people working on it serving to the number of people it does (millions?). It's the way we are making it. "Move fast and break things"is the shittiest way to make software.

All of the above works when the desired outcome is money. Not when it is quality of the product.

Coding has been solved in the same way that writing has been solved. Putting the sentences together is now easier, but having something interesting to say? That’s a lot harder. With the barrier to entry lower there is a lot of things that look good at the surface, but when you dig deeper, aren’t quite right. The nouns are in the right place and it has all the things school taught you a paragraph should have, but it’s just not an interesting story. That’s where all this software stuff is right now. It removed a barrier, but just like visual programming doesn’t solve it, AI can’t solve it either. It lowers the barrier but doesn’t solve the essence (is that a silver bullet reference? I’m not sure). AI can extrapolate and interpolate what’s already been done in fascinating ways but I need to see something new to really believe. Asking it to rewrite something it trained on (like SQLite or a browser) into a language that it was also trained on (rust or go) isn’t all that interesting from a software advancement perspective. I want to see imagination and so far I haven’t. But I have my required ai ticket like everyone else and maybe one day I’ll look out the window and be satisfied.

You can build software fast, but the more time you take the more you can be confident about it being correct.

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 opened Slack on macOS, the icon kept bouncing in the dock for a few seconds. I got impatient, switched to Ghostty, and started typing. Just then, the Slack window appeared, stole focus from Ghostty and the git pull command was sent to the group chat.

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?

I agree that software becoming worse (in some sense) but I don't blame AI.

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.)

Software quality is tied to the market incentives and always has been. AI isn’t going to make someone care about writing robust software and that is why we don’t see better software all of a sudden. The market doesn’t rewards apps that don’t break on every update, it doesn’t reward cobbling together multiple independent solutions, as opposed to using Microsoft as a one stop shop. If people could have gotten away with this in the early days of computing they would have, but computers were too low powered, and the knowledge too scarce.

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

Commercial software has been getting worse for at least a decade now, and the reasons are multifaceted and difficult to solve. They include the switch to subscription pricing, misaligned incentives at companies that make most revenue from "services" or, even worse, ads, the constant need to reinvent solutions to problems that were solved twenty years ago in order to show "progress", companies that build elaborate management systems to attempt to ensure that employees are replaceable, high turnover and a lack of institutional knowledge, and so on.

The ability to generate a lot of code will not solve any of these issues.

if coding is free, the number 1 issue that need to be resolved is separating features so people can roll back any part they don't like and the magic would be resolving all the gory consequences of such action well enough

As a non-technical person compared to the rest of HN, I think this has always been the problem of software made for non-technical audiences. The design was driven by programmers’ heuristics and trends in technology stack (e.g. if a company can hire a lot of JS devs bc JS is trending, they will choose JS even regardless of whether JS is the best choice for the problem).

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.

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

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

Reddit on iOS safari has been getting incrementally, nearly unusable worse. It had some sharp edges before but it seems they are moving faster now with the same or greater defect rate and shit is getting bad:

- 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.

The issue was never coding.

Today, developers assemble a Tower of Babel built of libraries they do not understand. Those libraries were largely built the same way.

There is “no value” in a company maintaining their own purpose-optimized HTTP client, database, GUI framework, or anything else.

Each layer adds features but subtle crappiness in the details not understood.

I shudder to think how many string libraries end up in a modern system…

“Practical” solutions like “this WXYZ fails 5%” of the time, let’s add a retry loop. Of course, this the next layer sees random failures that are hard to reproduce, so they add the same.

At some point our modern supercomputers are repeating millions of operations because of a stupid bug. The user just sees a sluggish app and gets annoyed.

We could write simple, understandable, efficient software that is a joy to ship and use. Unfortunately that doesn’t add value so we are extremely careful to never waste resources on such!

I agree with the author. I think everybody has strong or at least mixed feeling agent agentic coding and to me, the argument is always focused on the product itself.

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.

> Software may have been better back in the day, but that was mainly because it was much simpler. ... The bar for “user experience” has kept rising, but everything has become increasingly fragile.

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.

Right now, the majority of companies I interact with seems to look at their now (let's assume) increased capabilities, and turns up the speed. But there's other knobs to turn up instead. Robustness, quality, user experience.

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.

Personally I think the way to avoid a lot of this buggy new software is to use a LTS Linux distro like Debian as much as possible.

Obviously you cannot do that for everything. But any software you get from Debian repos (or similar distros) is at least safe from new bugs from all this new code.

I think people just think it getting worst because you use software for literally everything in your life now compare to before and this means you will most likely run into bugs more often.

On top of that software has to be build with more users in mind so you are often going to get bloated software. That why enterprise software is often horrible because they have to support multiple industries that all need different types of workflows and UI.

I have been using software for decades and there has always been horrible software. Like I'm mind blown that people think human always wrote good code, and that AI is somehow worst than human code. AI writes better code then the vast majority of programmers that's a fact. Yes, including you. Yes there are certain areas of programming that it sucks at but 99% of programmer aren't writing that code.

While there is increased complexity on top of all the software thats being built today, I reckon the focus on speed (and shipping to prod) over quality has also led to the increasing number of bugs. The mindset shift from shipping quality products (not just software) to shipping something that is good enough has been the mantra of management in recent years. When business schools and tech leaders prioritize the idea that we need to be more agile and every sprint needs to be a production release, these are the results we get.

We need new companies that market their products as enduring and reliable. The market wants it.

"Move fast and break things"

Everything is a minimum viable product that is constantly in flux these days. The decision makers and money movers are prioritizing rapid results and turnaround over quality product, maintainable codebases, institutional knowledge (debatable), etc

The incentive isn't focused on "Good" software, it's on making "profitable" software as fast and cheap as possible.

AI might have made things worse in the last few months but there have been a lot of bad trends on the desktop in the last decade, both software and hardware.

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.

A lot of the product misses come from large product teams where nobody owns anything, and where there's minimal internal goal alignment. I know that, at work, what I am incentivized to do has nothing to do with what I consider the most important work I could do.... and I also know that the maze I would have to cross to be allowed to do the better work is just not worth it.

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.

Software quality has been declining for long before AI was a thing.

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.

Just a little gripe, but near the end of the article he links to a site for something called "Omarchy" which appears to be a Linux distribution. If you click on the link, the only information available is in the form of a video.

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.

LLMs can't parse the entire codebase at once, understand it, and then make decisions based on that understanding.

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.

One of my favorite impossible puzzles is to sepparate security and feature updates. Ive made zero progress over many years.

I don’t think we can objectively say software is getting worse. I don’t expect an appliance website, a car infotainment system and a banking app to be the beacons of software quality and user experience. All those things would probably suck at any point in time.

Software has neither gotten worse nor become any better. All you're seeing is the cost of writing code approach near zero. As that happens the speed at which you see defects increases. Software is by its very definition "malleable". It is without (or very few) constraints. So it is very hard to get "prefect". That is why IMO Site Reliability Engineering will be one of the few fields that will remain, because until we build an _actual_ goodness to gracious Intelligent System that can think critically, including how systems can fail (which includes humans), software will be what is hat always been "soft".

For me, the problem was never the writing of the code. Building something takes care and rigor. Software development got where it is through years of accumulated practice: habits first, then safeguards, then structures that had actually been proven. Now people set the code aside and just describe their problem, and they have no real sense of what comes back, because nobody can review output produced that fast. Nobody is even keeping up with the systems we built to help us keep up. So we ship without quite knowing what we shipped, and the sloppiness follows from that.

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.

The issue for me is who controls the software

If it's open source and I can review it before compiling and installing, and I can modify it and recompile if I want to remove/change/add something, then I feel like I have some control

This is one reason I like relatively smaller software, less code

You could have made exactly the same critique in 2021. Microsoft has been selling the same OS since the 90s and it just gets worse.

Complexity + a lack of incentives to take time to get things right.

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.

> Software may have been better back in the day, but that was mainly because it was much simpler.

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.

To add to author's point, I did work at an organization that decided to focus on bugfixing for a full release cycle, and the PM was sacked after that.

we found that using a stable AI-SDLC process like: https://github.com/highflame-ai/ai-factory improves code agent assisted development dramatically specially when going from 1-100.

Large companies are on the path of replacing people who are bad at coding, with systems that are emulating humans who are bad at coding.

Coding has been solved in the sense that, per dollar spent, companies can get 10x or even 100x the amount of code of roughly the same terrible quality.

> My banking app requires, on average, three FaceID logins before the 3D Secure confirmation view appears.

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.

Personally I hope to use a lot less software in the future. Anything I want to know or do online I'll just ask an AI and it can wade through the sea of cookie popups or UI redesigns or whatever to get it done.

It’s not getting worse. We are just getting older.

The same reason computers keep getting faster but software keeps getting slower.

All of these complaints are about humans making user-hostile decisions, not AI. And software quality is not a reflection of its code quality. Never has been.

maybe once software in a certain category is solved, it no longer has incentive to improve User eXperience, but to improve the Asset Owner eXperience.

<They were congratulating themselves on what an amazing job they had done. I keep thinking about that post every time I have to fight their product.>

This is hilarious.

Agree with all of these gripes, they are everywhere and none of this golden age of SWE productivity seems to be making products better.

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.

I'm doing the exact opposite: I'm maxing out my PTO and taking long holidays. I'm pretty sure I'm not going to be in this field in five years time so why bother. It's time to figure out what other passions I have apart from programming.

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.

"Nothing works" if you're using poorly designed software.

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.

turns out the bottleneck was never doing things faster, it was doing things correctly, and we optimized away the people who knew the difference

I think you are right in being optimistic. Time will separate the wheat from the chaff. An I personally hope that free collaborative privacy first software built from curiosity, discipline and devotion will be the norm. Hopefully...

> Nothing works

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?

This is probably going to sound elitist, but it is how I've been seeing this whole LLM thing play out.

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.

We need automatic testing of user experience, that doesn't exist yet

I call this software "products", and not in a good sense.

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

Since upgrading iOS, my iPhone (13) will: - sometimes fail to open the camera - make the bottom half of the screen blank when you do email searches - use more battery - become unusable if you turn on any transparency effects.

> There’s no denying that these new tools have already revolutionized how we create and use software. They have raised upper management’s expectations for team output. They may have

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?

If coding is a solved problem, where are all the high quality, open source PRs is what I want to know. Where's the flood of improvements for Curl? SFML? SDL? Godot? Linux? ImGui? VLC? Firefox? GNU tools? Rust? GCC? LLVM? Why can I find *no* evidence of this?

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

Who ever said coding is solved??

Because at most companies, software engineers aren't paid to make good software. They're paid to ship flashy features.

> As I’m writing this, we’re in the middle of an AI-induced mass psychosis.

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.

Software will always be as bad as users world allow it to. Applies to every good and service.

That’s why i‘m using claude to literally write everything for myself! I cannot fix software-problems in my car or my fridge or my heat-pump. But I can start by replacing my own infrastructure!

The answer is money.

I don't get this post. It says software is getting worse, and then... gives a handful of anecdotal evidence. That could have been done at any point in the life of the software industry, including in the pre-agentic era. So the assertion behind the post doesn't really have any weight to it. Is there any actual, respectable evidence that software is actually getting worse? Also, what would worse even mean really? More buggy? Less reliable? Less creative, flexible?

Taken literally, this question just misunderstands what the point of coding is for most companies. The point was never to maximize quality of software, but to make the most money. Coding being "solved" implies it was a problem, and for companies using this framing, the problem wasn't "my software isn't good enough", but "it takes too much time and/or money for me to make software". Viewed through this lens, the "solution" of removing as much need for expensive humans to make the software is almost entirely unrelated to the quality of the output; if companies with this mindset could have released software cheaper or faster at a reduced quality before AI, they almost certainly would have.

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.

Pressure is on shipping things fast, not making things lightweight.

My assumption is that AI-generated code explodes the flaws in your existing codebase. If your architecture is bad or not documented, your docs are out of date or the goal of the feature request is vague, how should the AI (or even a good human developer) develop high quality software?

We have better shovels now, why are the holes we are digging ourselves into getting deeper????

rant first: oh, I recently heard about you from a friend working in a company after I mentioned that I also got into photography. Nice work on pixelpeeper.com

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 :(

I remember noticing the same thing a decade ago. I don't think it has anything to do with AI.

This is a business culture problem not a tech problem.

Author seems to be blaming the hammer for the house not getting built right. Software is increasing in complexity, and perhaps is outpacing testing.

> Until this attitude changes, the great software quality decay will continue.

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.

LLMs are an amplifier. Most software engineers/architects/developers are bad and always have been. We have amplified the bad, and so we have the modern world.

A garden needs a gardener. It's the end when people stop caring or when starts chasing superficial metrics and tawdry toys.

we spent 40 years making computers faster so that apps could spend the first 30 seconds of every session loading a welcome animation

It was always like this.

> This quarter, we won’t be releasing any new features, and we have no plans to redesign anything — we will exclusively focus on fixing bugs.

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.

AI is the private equity of software and digital media, it makes the first 80% way easier and the last 20% way harder so no one bothers with the last 20% anymore. It’s the ultimate enshittification tool.

Even non-VC-backed software or open source projects suffer from this.

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

check out The Utopia of Rules by David Graeber https://en.wikipedia.org/wiki/The_Utopia_of_Rules

A lot of this is about bureaucracy

Code is the easy part.

I suppose that because we trained llm’s on code with bugs in it will write code with bugs in

This post and the comments so far reminded me of 1984's two minutes of hate. When is Hate Week?

The claim that software has regressed is hard to accept. Compared to the past, we now have far more platforms to support and far more things to memorize. And if you actually try using software from 15 years ago, you'll see it had far more critical bugs than today's software. I think most of this is just nostalgia bias.

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.

Someone saying software has been solved, but nobody that takes the drivers seat agrees

Weaving fabric and sewing clothes has been "solved", but there is no shortage of garbage quality shirts.

I've seen some shit.

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.

I have the same impression when I use things that are around me every day. Everything is broken and seemingly nobody cares. It seems that the teams developing software never use it themselves and do not care about bugs and terrible usability problems. It seems the management does not use any of the products that their businesses produce. And it seems that the ubiquitous breakage is just accepted as the status quo.

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.

These tools combined with silicon valley motto of moving fast and breaking stuff fast created the perfect storm

> 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

yep noticed a major decline in product stability over the last 5 months. I don't think explained by use of vibe coding but who knows.

I think the truth is whether people want to admit it or not is that coding has not been solved, and producing good software is really not any easier.

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

Weird strawman. Who said coding has been “solved”?

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

MacOS contstant trolling with tab switching. I regret each day of life I need to use this shitty OS because of corporate. In linux these things will never happen

> those bugs affect your ability to focus on driving

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

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

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.

Sad cause its true

They got rid of test managers. Then testers. The industry said everyone should be responsible for testing— which means no one is.

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

>Nothing Works and Everyone Is Euphoric

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.

Use open source everything. If you have the source to something, you can change it. If you can change it, you can fix it. Run Linux and Firefox. Fork every last damn program and have AI fix every papercut that you don't like.

> I opened Slack on macOS, the icon kept bouncing in the dock for a few seconds. I got impatient, switched to Ghostty, and started typing. Just then, the Slack window appeared, stole focus from Ghostty and the git pull command was sent to the group chat.

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.

Imagine you find yourself making TC $1M+ a year owning some beloved piece of software.

Do you A) tell your management hey it's absolutely perfect as is, let's just chill, leave it alone and let the money roll in. Or B) tell management about the need for whatever new hotness and you're going to get it implemented ahead of schedule and under budget. And then you do! Oh but the software is objectively worse because it was already perfect.

It's pretty clear what the overwhelmingly popular answer is to that question.

Those two twitter links with people that got hospitalized might just be people trying to get their 5 seconds of internet fame by (pretending to be) doing something dumb.

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.

I've also noticed so many pieces of software becoming worse and worse, either with useless features (basically any new thing on Slack in the past year) or with a huge amount of large bugs, over the past year.

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.

I think the article misses a bit the main focus. For instance:

> 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.

God, those "software is getting worse everywhere" takes are tedious.

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.

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

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.

Customers speak with their wallets, and OP doesn't like what they're saying.