Something is wrong with software. Windows crashes randomly when opening files. iOS can't let you edit a message until it finishes a fancy animation. PlayStation boots are a coin flip between working, crashing, or demanding yet another firmware update. Twitter blacks out chunks of the screen when scrolling. Uber trips disappear right after booking. YouTube picture-in-picture freezes the video while audio keeps playing.
This isn't isolated incidents. This is a pattern. Software that used to work is slowly falling apart.
The Usual Suspects Are Innocent
When people notice software quality declining, they reach for familiar villains. Electron. React. JavaScript. AI-generated code. Rust evangelists say we need more Rust. Native app purists blame cross-platform frameworks. Everyone has a theory.
But look at software that actually works well right now:
Ghostty (Zig): Open source, one maintainer, passion project, already wealthy.
Lossless Cut (Electron): Open source, one maintainer, passion project.
Zen Browser (Chromium patches): Open source, small team, passion project.
These couldn't be more different technically. One is Zig, one is Electron, one is Chromium patches. None of them are Rust. None of them use SwiftUI. Yet they're all remarkably stable.
What do they have in common? Open source. Small teams. Passion projects. Maintainers who either already have money or are doing it for love, not profit.
The technology stack doesn't determine stability. The people and incentives do.
The Cloudflare Lesson
Remember the massive Cloudflare outage in November 2025? It was caused by code written in Rust, reviewed by humans, with no AI involvement. The culprit was an unwrap call that panicked when a config file exceeded an expected limit.
This was one of the biggest outages in internet history. They did everything the "software quality" crowd says you should do. They used Rust. They didn't use AI. Humans wrote and reviewed every line. It still broke.
The problem wasn't the language or the tools. The problem was complexity.
Software Is Getting Old
The software we complain about is ancient.
iOS has been around since 2007. Twitter since 2006. YouTube since 2005. Gmail since 2004. These aren't new products with growing pains. These are 15-20 year old codebases that have been accumulating features, patches, and technical debt for decades.
The number of lines of code in Gmail today is probably 100 to 1000 times larger than when it launched. The iOS 7 install size was 2.5 GB. iOS 26 is almost 13 GB. The codebase has grown exponentially while the fundamental architecture remains the same.
As software gets older, it gets bigger. As it gets bigger, it gets worse. And several forces are driving this complexity explosion simultaneously.
Feature pressure: When one company releases a feature, competitors rush to add it. Branching in AI chat apps is a perfect example. OpenAI, Google, and others all scrambled to add it, often poorly, because users expected it.
Platform multiplication: Software no longer ships to one platform. A YouTube update has to work on the web, iOS, Android, Apple TV, Kindle, Fire TV, Roku, and more. Each platform adds complexity and potential failure points.
Team scaling: Engineering teams have grown massively, but QA, security research, and code review haven't scaled proportionally. More code is being written with less oversight.
Economic incentives: The willingness to merge and ship has never been higher. Getting permission to ship used to be hard. Now the pressure is to move fast and fix later.
AI Isn't The Problem (Or The Solution)
The AI discourse around software quality is exhausting. One camp blames AI for everything. The other thinks AI will save us. Both are wrong.
There are two statements that are both true, but people struggle to accept them together: software quality is bad and we need to make it better, AND making software more accessible with better tools, frameworks, and AI is a good thing. Most people can only hold one of these beliefs at a time.
AI does make it easier to write more code faster. That contributes to the complexity problem. More PRs are being merged. More features are being shipped. The desire to ship has never been higher, and AI accelerates that. But that's not the same as AI being the cause of software decay.
iOS 26 wasn't written with AI. Apple barely allowed good AI models until recently. The bugginess of iOS 26 has nothing to do with AI and everything to do with attempting a major UI overhaul on top of a massive, aging codebase. iOS 7 was blamed for similar problems when it launched, and the codebase back then was probably a thousandth the size of iOS today.
Software getting easier to write isn't why things are broken. Things are broken because the software we rely on has been accumulating complexity for a decade or more with no fundamental reset. AI isn't going to save us, but it's not the villain either.
The Uncomfortable Truth
We haven't changed our core software stack in over a decade. We went from constantly switching operating systems, email clients, and social platforms to settling on a handful of options and staying there.
Before Git, we changed version control systems constantly. Before iOS and Android, there were dozens of mobile platforms. Before Gmail, we hopped between email providers regularly. Java won mobile because it could run on all the different platforms with a single codebase. Now we've been on the same stuff for 10-20 years.
This stability sounds good, but it means the software we depend on just keeps growing. And growing software is dying software.
Nobody wants to move to a new solution because these platforms were built to encapsulate you within them. You might hop between Android and iPhone, but you're not trying a third option. You might try a new flavor of Linux, but it's still Linux. The lock-in is real, and it keeps us trapped on aging, bloating codebases.
Interestingly, TikTok is one of the newer major platforms, and it tends to be more stable than the others. That's not a coincidence. Newer software hasn't had decades to accumulate complexity.
What Actually Helps
The software that works well shares common traits: small teams, passion-driven development, focused scope, and sustainable funding that doesn't demand infinite growth.
Valve's work on Proton is exciting because it's a wealthy company investing in open source infrastructure out of genuine interest, not growth metrics. Independent developers building tools they actually use tend to produce more stable software than large teams building for abstract user personas.
The path forward isn't switching to Rust or banning AI or going back to native apps. It's supporting smaller, focused software built by people who care. It's accepting that software doing everything will never be as stable as software doing one thing well.
Things will probably get worse before they get better. Every update makes software more bloated. Every new feature adds complexity. The incentives pushing toward bigger, more complex software aren't changing.
The best we can do is seek out alternatives built by passionate individuals, support independent software development, and keep pressure on the big companies to prioritize stability over features.
Software has gotten old. Old software gets big. Big software gets worse. That's the cycle we're stuck in, and breaking it requires more than better tools or smarter AI. It requires fundamentally rethinking what we expect from the software we use.