TL;DR: I have been a professional software engineer since 2004. More than 20 years. I don't think I can do it anymore. LLMs are fucking up software engineering beyond recognition. I'm at the point where I think starting over in a new career is probably the best path for me.
This post is about how and why software engineering is being ruined. A future post will be about exploring new career paths I can pursue instead.
While this post is about software engineering, that's not the only thing I care about. Rest assured I know and care about all the other ways that LLMs are making the world worse. This post is long enough without a comprehensive list of all the crimes of the LLM industry. There will be other posts for that.
Is The Bubble Going To Burst?
In 2023 when ChatGPT-3 was new, I thought the threat to software engineering was somewhat overhyped. That wave of LLMs produced code that was often wrong in subtle but important ways.
Also, LLM use was, and still is, heavily subsidized by investors willing to throw billions of dollars down a bottomless pit. Users are not paying the full cost of these things. Throwing billions of dollars down a bottomless pit is not sustainable, so someday users will have to pay what LLMS really cost.
At that time, I hoped the whole thing was a bubble that would pop soon and things could go back to normal.
We often confuse what we expect to be true with what we want to be true. People who think LLMs are bad expect the bubble to pop and the LLM push to fail. People who think LLMs are good expect them to succeed. That leaves out these other two possibilities:
I now believe the upper-right quadrant, "LLMs are Bad But We're Stuck With Them", is correct. Two events changed my mind. First, DeepSeek, a cheap Chinese open-weight model, showed that it's possible for LLMs to be trained and deployed much more cheaply than the frontier labs are doing. That means that even if OpenAI and Anthropic perish as companies when the bubble pops...
(onion sicko guy saying "yes, ha ha, yes")
LLMs as a technology will, tragically, continue to exist and to plague us. The second event is that around the end of 2025, there was, tragically, a significant step up in the quality of code that LLMs like Claude Code could produce, to the point where it's no longer insane to consider putting an LLM-generated feature implementation into production after appropriate QA.
So, software engineering is not going to go back to normal. There's a range of possible outcomes, like one of those diagrams of a hurricane's cone of possible paths. We've got enough evidence to know this hurricane isn't passing harmlessly out to sea, but we still don't know if it will hit Alabama or Florida. You know? Massive destruction is guaranteed somewhere, but we don't yet know who has to evacuate.
{picture}
How Much Unemployment Are LLMs Actually Going To Cause
The path of this hurricane depends on unknown variables like: How reliable with LLM code generation end up being? And how expensive will it be to run "agentic" workflows at the high-end of reliability?
If high-quality code generation ends up expensive, maybe we use it sparingly, in a development process that is still mostly human-designed. If error and hallucination rates remain high, maybe a lot of human labor remains necessary in code review, testing, and QA. Maybe there are somewhat fewer software jobs, or maybe the total amount of software created goes up and the number of jobs holds steady. Maybe the jobs pay less and are less fun, but they are generally recognizable as the same sort of software engineering job we used to have, just with higher-level tools.
But if LLM code generation gets good enough, and cheap enough, there's a future where writing code by hand becomes something like blacksmithing - a historical craft that a few people keep alive as a hobby because it's cool. In this future, maybe there's no such thing as a "software company" anymore: end-users pay their LLM subscription, they describe what they want their computer to do in natural language, the LLM generates bespoke custom code for them, and they run that. Why pay for SAAS when you get code perfectly customized to your personal needs? Maybe you have an endlessly-customized personal application, or maybe you run each custom program once and then throw it away. Maybe no two users in the world are using the same code for anything.
(Maybe that sounds good to some people? But a world where nobody understands how any of the code works... that seems really bad to me.)
In a middle path, "software companies" still exist, they hire for "software jobs", but the jobs are just babysitting a team of Claude Codes all day. In that world, software engineering is effectively dead. Even if there are jobs, no "engineering" is taking place. Babysitting Claude Code instances is not engineering.
There is one more unknown variable. Maybe LLMs can't actually replace all coders, but CEOs think LLMs can replace all coders. They do a massive amount of damage to their own companies based on this false understanding. I saw this happen at my last startup company: the CEO vibe-codes something, they get some basic functionality working, they think "wow that was so easy, what do I need an engineering team for anymore". (Being unaware of the gulf between "got some basic functionality working on my computer" and "have a shippable software product".)
So the path of the hurricane's destruction depends not only on how good LLMs are at generating code in reality, but also on perception. The longer the decision-makers remain out of touch with reality, the more damage.
link to "Eviscerating global decision-making"
We've already seen some high profile cases of companies firing a bunch of workers to replace them with LLMs, then having to backtrack and hire the workers back after realizing LLMs couldn't do the work. So there might be jobs in the long-term, after severe disruption in the short term.
The evidence we have so far is that software engineer employment hasn't really gone down. Except in the case of entry-level engineers, right out of college: Those openings have suffered. Which is all by itself a big problem, for reasons I'll get to. Overall employment could still crash, but it's not happening yet. I think this means the maximalist "software companies don't exist anymore" future is unlikely, or at least pretty distant. We're probably looking at the futures where job still exist... but they suck a lot more.
Would You Want Any Of These Jobs Though
{ venn diagram }
An ideal job is at the intersection of "Makes $", "Helps Somebody", "I Enjoy it", and "I'm Good at it".
It's not like software engineering was my dream job, exactly, but it did exist at the intersection of things I enjoy, things I'm good at, and things that make money.
For 22 years my experience of software engineering has been, at best, an actively fun activity that I even voluntarily do as a hobby. And at worst, basically tolerable as a day-to-day work activity.
What makes it satisfying: A kind of problem-solving almost like detective work. The creative fulfillment of having an idea and making it real. The thrill when the thing actually works right for the first time. The pride in craftsmanship. The learning opportunities. Developing your skills. Deepening your understanding of the problem space and of the codebase.
You may notice that all the satisfying things about the job depend on caring about the craftsmanship and taking enough time to do it right.
In the past year at work I experienced an increasing amount of pressure to "go faster" by merging vast amounts of minimally-reviewed LLM slop code.
A CEO's mission is to reduce costs, and one of the main ways they reduce costs is to externalize those costs onto society, and forcing the overall standard of software quality to get worse is one way to externalize costs onto society. The software industry is already deep into late-stage enshittification [cory doctorow link] but I expect the overall quality of software to go down even faster as companies push out more and more LLM slop code they don't understand.
A successful software project is an embodiment of functional interpersonal relationships and processes among the team and an embodiment of their collective implicit and explicit knowledge about the problem domain. It's fragile.
When developers start thoughtlessly substituting LLM output for their own work, they contribute to a process of de-skilling themselves. They unravel the fragile team relationships, they lose implicit knowledge, they lose functional process knowledge. The code base goes from an intimately familiar, carefully tended garden to a mysterious black box full of unknown machine-generated spaghetti code.
Doing things right is slower, and I don't think software companies are going to have the patience for that. "Code quality" is mostly something that matters to developers, but has little direct impact on the bottom line. Poor code quality manifests as slower and buggier software, maybe longer time between releases because development is more difficult, but most users can't tell anything about code quality.
And maybe people would be right not to care about code quality, except for one reason: security.
Software Security Apocalypse
We have heard a lot lately about high-profile cases of LLMs "escaping the sandbox" and "hacking" other companies servers. But there are multiple competing interpretations of what happened.
If what happened is framed as "OpenAI hacks HuggingFace servers by failing to take appropriate security precautions during an experiment" then it becomes obvious OpenAI committed a felony, but if they can frame it as "Oh wow, our AI is so powerful that it broke containment, went rogue, and hacked another company's servers all by itself" then instead of a felony, it's free marketing!
So there's a huge incentive there for LLM companies to portray these hacks as spooky sci-fi stories rather than dumb mistakes. Notice that google followed this up with "Our AI did too!" - they don't want to be left behind in the free marketing. We have to keep that in mind.
Even though I don't think LLMs are going rogue and hacking servers by themselves, I do think that LLMs are going to make computer security much, much worse. First, because the use of LLMs to generate code results in worse-quality code that fewer people understand, which has more security holes in it. Second, because LLMs as a tool in the hands of the bad guys reduce the cost of finding existing security holes in deployed software. There are a lot of poorly-secured servers out there, which haven't been hacked yet only because it's a lot of work to find them. Even if LLMs don't produce any new hacks, they reduce the effectiveness of "security through obscurity", by making it easy to rapidly try a lot of known hacks against a lot of servers.
If you add in the fact that LLMs could also make finding new hacks easier, by searching existing code-bases for vulnerabilities - things could get very bad. "Large parts of the internet become unusable" bad.
Working at a company that's rushing insecure LLM slop code into production means you are actively making the world worse by going to work every day.
(This points at one possible career direction: get good at security, become a professional security expert, get jobs finding and fixing vulnerabilities in software before the bad guys find them. That's probably pretty lucrative. But it's also just so... zero-sum. A race between the people using LLMs to find hacks and the people using LLMs to prevent hacks. If we work very hard, maybe interent security only gets a little bit worse than it was before LLMs.)
Moral Rot
This deserves a longer post, but the "silicon valley vibe shift" of the 2020s (which is the polite euphemism for "Software monopolies betrayed democracy and began openly supporting the fascist takeover of the USA") was in my opinion largely driven by a shift in the balance of power within software monopolies, between the ownership class and the workers. The ownership class being the kind of psychopathic billionaires who always wanted to be oligarchs in an authoritarian system - and the workers who had previously had enough negotiating leverage to keep them partially in check.
Not that workers were all morally blameless, of course! But to the extent that e.g. Google ever followed its own "don't be evil" motto (those days are now long gone), it was because Google needed good engineers, good engineers were hard to find and hard to train, and that gave them high bargaining power, and at least some of them, some of the time, used that bargaining power to refuse to write code that was quite as evil as what the CEOs wanted. For example, refusing to work on autonomous weapon systems.
CEOs hated having to rely on workers with any kind of leverage, of course. One of the many reasons they're so excited about LLMs is that now, if an engineer refuses to write some code that's evil, the CEO can make an LLM do it. Bosses are very excited to fire all of the idealists. The swing in bargaining power back towards bosses means the companies are going to be worse for the world. I think that's what we're seeing in the software monopolies now collaborating with the fascists.
The new Silicon Valley broligarchs are happy to create mass surveillance systems and hand them to authoritarians as tools of totalitarian control. They're happy to make autonomous weapon systems that murder civilians. They're happy to give ICE tools for rounding up innocent people into concentration camps and eliminating "due process of law". They're happy to be the ones deciding what speech is allowed and what is censored.
It is not morally acceptable to work for one of these companies.
What I think will happen
Software companies are still a thing, but they have a 10-person engineering department doing the job of a formerly 50-person engineering department. The engineers are expected to make releases at a pace which makes any craftsmanship, or basic quality control, impossible.
Software quality goes way down. Most of the software is slop code that nobody understands. Everything is jankier, buggier, more user-hostile, harder to fix, and more insecure.
CEOs save money by firing 80% of the engineering team, pass the savings on to the shareholders, and if the result is full of security holes? Well, the EULA we make users agree to says we're not legally responsible for those, so they are somebody else's problem now. Profits successfully privatized, risks successfully externalized onto society: CEO's mission accomplished. They basically force everyone to accept a worse standard of software while profiting off the difference.
Hand-crafted software is not economical to make anymore; you can do it as a hobby but not a job.
The 10 jobs in the formerly 50-person engineering department are all the senior positions: the architects, the specialists, the sysadmins, people with irreplacable knowledge of the weird duct-tape kluges that keep everything running, etc.
Those people each spend most of their day babysitting teams of Claude Codes and Devins, are heavily overworked, don't have time to care about the quality of anything they commit, and don't have the leverage to object when the company wants something evil.
There are no junior or entry-level positions, because those have all been replaced with Claudes and Devins. Wait, doesn't this mean that there's nobody to replace the senior-level positions when they retire? Doesn't this mean institutional and professional knowledge is getting lost forever because its not getting passed on to anybody? Yes and yes. But that doesn't affect next quarter's profits so why would a CEO give a shit?
So If I don't make a career change, my fate is being either fired or being one of those 10 miserable, overworked senior guys, babysitting Claudes, churning out slop, no craftmanship, nobody to train or mentor, nobody to replace me, watching the company crap out slopware that makes everybody's lives worse, and knowing I'm responsible for it but helpless to change it, counting down the days till i can retire.
Fuck it, I'd rather be one of the ones getting fired.