What is the Future of Software?

Much ink has been spilled on the future of software and LLMs [1, 2, 3, 4, etc.], Software Engineers (SWEs) are either the second to join the permanent underclass (right after mathematicians) or the struggling protagonist against a never ending mountain of slop, depending on who you ask. Previously, the dominant view was that SWE's were first on the chopping block of progress, now the view seem to be that the monkey's paw has curled and the SWE role still exists, the job just sucks way more now [1, 2]. But I'm not a SWE, so this won't be an article on the professional impacts. However, I have written, read, and interacted with a fair amount of software, so I would like to dedicate some thought to where this software stuff is all going.

To begin with, we need to understand the relationship between LLMs and software. We are now more than one year into "coding being solved" (per certain token merchants), so let us take a look at the result of that (I'm not really sure how that helps new releases of models though, like what are you going to do, solve something even more?). This past year, the end user experience of most software products is worse than before, but in my experience this is mostly due to product decisions rather than code implementations (e.g. putting ads in previously ad free software plans). The performance (i.e. speed and bugginess) of software is continuing a long worse-ward trend (is this the Jevon's paradox everyone talks about, when we have more RAM but use more of it to accomplish the same tasks less efficiently??), and that trend seems unchanged. As Gerald Weinberg said many years ago, "If builders built buildings, the way programmers writes programs, the first woodpecker to come around would destroy civilization" (and the standards haven't gone up over time). Even in the beating heart of LLM coding, Anthropic, software continues to suck. Claude code is a slow buggy mess. Why the hell is cowork electron bloatware, don't they know you can vibe code native apps now? Maybe you shouldn't blame the LLM, but the people, maybe the typhoid Mary of electron is to blame. The main noticeable change that LLMs have on the end user of software is chatbots embedded in them (e.g. software for managing job candidates now has a option to let AI fill out your opinion of them, which doesn't seem problematic at all). Certainly software is not noticeably less buggy (even in software from companies that tell me all their code is LLM generated), in many cases it seems to be more buggy. I don't remember the last service I used that actually had 3 nines of uptime (except ghost, which I what I use for this blog). The point being, coding being "solved" doesn't seem to have mattered much from a user perspective.

So the future of software is just the same slowing rotting carcass of bloated code, destroying anything it touches until the digital world completes its sundowning? That is to say, the future of software with LLMs is the same as the future of software already was? So what's the big deal with LLMs then?

It seems the argument is not that LLMs will result in any meaningfully different software, but result in different mechanisms of software production. The scale of this impact depends on a very simple binary question: does humanity (or a human) need to understand the code? Unlike all previous instances of moving up the abstraction hierarchy (e.g. moving from assembly to C) or previous instances of automation (e.g. replacing people who manually screw things with machines that do), LLM generated code does not naturally have any person who understands what it is doing. When you move up the abstraction hierarchy, there are whole teams of devs who have paved that path for you, and that knowledge is possessed by people. If the answer is yes, then LLMs are pretty worthless. Meaningful understanding of code takes time, and thus LLMs could accelerate the typing process (since if the code takes a specific design decision out of your hands the amount of time to read it negatively impacts the speed advantage) but that doesn't matter that much. Sure, they would have other impacts, on code review or security analysis or that sort of thing, but on the generation of software it would be minimal. If this were the case, then most current usage would be a disaster, as massive systems are being built that no one understands, all while the skills and talent pipelines atrophy. This would mean we are in a very scary situation that would have severe negative consequences in the future.

Thankfully I am here to reassure you, the answer the industry has arrived on is a resounding no, so you have nothing to worry about. The only reason humans would need to understand the code is to help shape it to be better, faster, or higher quality (but that doesn't matter if humans aren't in the loop, and making software better hasn't been a goal of code for decades), or to take liability for it (which is already barely a requirement, software engineering disasters get a slap on the wrist compared to other engineering failures). The later has been entirely solved by LLMs, since they can arbitrage blame by having agentic LLMs do things which make them totally immune to the consequences. There is no need for humans to take liability or prevent the code from doing something if LLMs can take the liability, so what possible reason would humans need to understand the code? This allows them to generated software faster and cheaper than ever (or so I am told, I have yet to see any of the software I interact with get cheaper or have bugs fixed faster).

I want to respond to an argument that I see lots of anti-LLM people have on my previous point, you are surely saying to yourself, "these LLMs generate bad code, so they don't meet the standards necessary for shipping code" (or something to that effect). Critics argue that the models don't produce very good code, but this totally misses the point (some people argue against this by saying the models produce massively better code than they could write, but that's just a skill issue for them). The point of LLM coding is that code quality doesn't matter any more. We all saw the claude code source code, yea it's garbage that a freshman CS student could vibe code better and doesn't adhere to any of the most basic software patterns that would allow for better performance. But it doesn't matter. If LLMs make bad code, who cares, it's not like you ever have to maintain it. You will never engage with the code on any level except through an LLM. Code reuse, design patterns, documentation, etc etc are tools for aiding human development. Those things simply do not matter if you do not ever look at the code or attempt to understand it or build any sort of model of what it is doing or what tradeoffs are being made. All of that is dead.

Critics of LLMs also bring up deskilling but (again) this doesn't matter. Obviously LLMs makes you bad at coding (and probably whatever else you use them for). This is the most basic thing in education, you get better at things by doing them, so if you never do stuff, you will get worse at it. LLMs makes you worse at generating code or thinking about how to solve coding problems or how to be able to think for long periods of time or how to formulate ideas or approach problems in unique ways or have original ideas, but none of that matters any more. People constantly are deskilled by technology, but if the outcomes are cheaper, then we think that is a good thing.

What does this mean for the future of people who make software? I don't know. It seems there are a few predictions people have: perhaps coding will simply be less of the job and more of it will focus on all the other parts that SWEs famously like (such as meetings and documentation), perhaps the agents will always need a churner and it will transition into low skill labor that we can further outsource and San Francisco will become the epicenter of the new rust belt, or perhaps, as Anthropic employees say, (salivating at the thought of others suffering), "SWEs are horses to the glue factory, being driven out by the car of progress" (paraphrased from a blog by a Anthropic employee). The standard rebuttal that you see to these uniformly pessimistic arguments is that, actually, LLMs are a force amplifier, and they will allow senior engineers to be massively more productive but anyone less than a 1x engineer will be massively worse (of course, the students and fresh graduates are fucked, but that's true in any scenario). Unfortunately for them, this is cope. Coding with LLMs might be joyless and soulless but most importantly it is skill-less (even the LLM coding essentials that people think matter, often don't). People, especially at Big Labs, have a concocted a rotating selection of dumbassery about loops or software factories or whatever the topic of the month is, seemingly in an attempt to cover the fact that somehow they are bad at something that doesn't take any skill. If you are coding with LLMs, for any task, in any field, for any purpose, anyone (above some baseline level of competency, not dependent on domain expertise) can achieve the same outputs (this is readily seen in the area of vibe proofs). This is also why critics who are concerned with the destruction of the junior engineers (who would then become senior over time) need not fret, since seniors aren't needed either.

Usually the people saying this are mid career. The younger crowd (but old enough to not be bots from LLM education), don't really care as much since they haven't spent much time committed to an area (and have less emotional attachment to that skillset) and can adapt and learn new things, those closer to the end of their career can just punt adoption down the road till they can finally escape the rat race, but the middle career people have sunk their life into stuff that they now have to pretend like it mattered. Their mental resilience is impressive, and their dedication to the slop might delay their demise for a few extra years.

Another class of people have carved out some space coding manually, perhaps they have repos on codeberg, and they form communities and maintain and develop software for humans and by humans, and are dedicated to maintaining the ability to code and solve problems the traditional way. Maybe they like programming, maybe they don't want to give money to the guys who say they are going to kill us, beats me. But their peaceful isolation has made them less aware of the collapse outside. When one prominent community member or foundation becomes inseparable from the LLM companies, this is a shock. But the next time they go on github, will be exactly like this scene in Body Snatchers (1993): https://www.youtube.com/watch?v=Lk2gIdLgwz4, "What happened is not an isolated incident. It is something that is happening everywhere, to everyone. So where you gonna go? Where you gonna run? Where you gonna hide? Nowhere. Because there's no one like you left."

I didn't talk about cybersecurity at all in this blog, but that's because cybersecurity is also already solved, just stop connecting computers to each other. You don't want something to be hacked? Just don't put a internet connected computer in it. We put a man on the moon without PHP, I'm confident we could do it again without PHP.

As much as I talk about LLMs, the future of software really has nothing to do with them. The future of software faces the same fork in the road that is has for decades; it is either the prison of the past, the iron bars of closed-source Coercionware damning us to digital exploitation, or it is software that works. In other words, the future of the future is the same as the future of the past: worse.

(if you couldn't tell, at least half of this blog is tongue in cheek, I'll let you figure out which half)