At my last software job ("last" as in "previous" but maybe also "last" as in "final"), one day late last year, I submitted a pull request. A big one, that I had been working hard on for a couple weeks. I asked my manager (who was the CTO, it was a small company) for code review.
He pasted a code review that he had obviously had an LLM generate for him.
This was the moment I knew we were cooked.
I mean, what are we even doing here? Why did I spend weeks writing this pull request if nobody cares enough to look at it? What am I doing in this job? What are any of us doing?
Meanwhile, the CEO of this company was excitedly handing over all of his passwords and credit card numbers and stuff to ClaudeBot or ClawedBot or MoltBot or whatever it was called that week so it could take over his computer and do God knows what. (This was the same company where this happened.)
I didn't work there much longer.
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 going to have to start over from scratch in a new career.
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.
Software engineering wasn't perfect, but for most of the past 20 years, it did hit a combination of things I enjoy, things I'm good at, and things that make money. And some of the time, it even helped people.
Come, join me on a magical journey into each individual circle of the Venn diagram as we explore how LLMs are making it worse!
Does It Make Money Anymore?
or: "How Much Unemployment Are LLMs Actually Going To Cause?"
I used to be an LLM skeptic, but my position has evolved to LLM pessimist, for reasons I explain over here. I don't think software engineering is ever going back to normal, even if/when the data center bubble pops.
What's going to happen instead, nobody knows. There's a range of possible outcomes, like one of those diagrams of a hurricane's cone of possible paths. We've seen enough evidence to know this hurricane isn't passing harmlessly out to sea, but we still don't know if it's Alabama or Florida that will take the brunt of it. You know? Massive destruction is guaranteed somewhere, but we don't yet know who has to evacuate.
The path of this hurricane depends on unknown variables like: How reliable will 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.
Maybe CEOs think "Great, in that future, I can run a software company with no engineers". I think it's more likely that in that future, there simply aren't "software companies" anymore. Why pay for SAAS when you can have the LLM generate a bespoke app personalized to your exact use-case? Maybe in this future, 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.)
There's a lot of other possible futures between these extremes. Maybe LLMs can't actually replace all coders, but CEOs think they can. (After all, OpenAI and Anthropic have been selling this idea really hard to CEOs every day for the past few years). A 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"). They fire a bunch of people and do massive damage to their own company before they figure out they needed those people. The longer the decision-makers remain out of touch with reality, the more damage.
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 SAAS companies had a scare but their business hasn't collapsed.
Workers in the most AI-exposed industries are more afraid, but haven't actually seen more layoffs than anyone else. Software engineer employment hasn't really gone down. Except in the case of entry-level engineers, right out of college: Those openings have suffered.
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 some software jobs still exist.
"LLMs Are Killing Software Engineering" doesn't have to mean all the jobs literally vanish. If the "software job" of the future is just babysitting ten Claude Code instances all day, well... it's a job, but nothing describable as "engineering" is taking place.
Do I Enjoy It Anymore?
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: 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. Debugging generates an endless supply of fun little brainteasers to solve. They're fun the way riddles or mystery novels are fun. You get to feel like a brilliant detective when you figure one out.
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.
Ta-Nehisi Coates, in an interview about his book The Message, said something that really stuck with me: writing is thinking. When he starts writing an essay he doesn't actually know yet what he believes. It's in the process of struggling with the text, trying to fit together different pieces of evidence, metaphors, and different perspectives, it's that struggle that makes him figure out what he actually believes.
When you tell an LLM to generate text instead of writing, you skip all of that thinking. you deprive yourself of it. And I think writing code is like that, too: coding is thinking! Making code that's bug-free and correctly handles all the edge cases forces you to think deeply about the problem you're trying to solve! You deprive yourself of that every time you have an LLM do it.
Only problem is that thinking deeply isn't what you're getting paid for. It's the first thing to go when CEOs see an opportunity for cost savings. 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 lot of bosses do not even care that the machine is getting things wrong.
There is something very sad about realizing that LLMs are going to take the fun parts of the job away from you, by making them economically uncompetitive to spend time on. You get the stress of being responsible for the machine's mistakes without any of the upside.
Am I Good At It Anymore?
"Hey Nindokag, aren't you just being a grumpy old man who refuses to change with the times? So you invested a lot of skills in the old way of doing things, and the new way of doing things makes those skills obsolete, so what? Aren't you just whining because you don't want to have to make the effort to update your skills to the new way? How are you any different than a programmer in 1976 who didn't want to move off of punch cards, or in 1986 who didn't want to try object-oriented programming, or in 1996 who didn't want to use the internet?"
So says my inner devil's advocate.
I didn't complain when switching to Python obsoleted my experience manually allocataing and deallocating memory in C obsolete; I said "good riddance to that!".
But LLMs are qualitatively different than, say, the process that's been going on for decades of replacing of lower-level languages/abtractions with higher-level languages/abstractions. The direction LLMs are pushing in is to de-skill everybody, make us all interchangable button-pushers, so the whole concept of having skills or knowledge matters less. in which case "good at the job" is not something it's possible to be anymore.
Or is it? I've heard things like "Only a senior engineer can properly evaluate the LLM's output, therefore senior engineers' experience is still valuable". Maybe?
But that's not what it felt like over the last year. It didn't feel like we were encouraged to use our skills to properly evaluate the LLM's output. If that was the case, we would have been doing more manual code reviews. Instead, we were doing less. It didn't feel like we were trying to improve our skills; it felt like we were abandoning them.
A successful software project is like a healthy shared garden, where the roots are strong, where everybody knows where each tool is kept, and which plants need how much water, and whose turn it is to pull weeds. What I'm trying to say is that the interpersonal relationships are working, and we have working processes that embody our collective explicit and implicit knowledge about whatever it is we're trying to grow.
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.
When I used Claude Code to generate new features, I could feel myself getting dumber. More detatched, less involved, less curious, less patient. It felt bad!
Does It Help People Anymore?
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. I expect the overall quality of software to go down as companies push out more and more LLM slop code they don't understand.
The thing about software quality is that it's mostly invisible to users, so it's easy to de-prioritize in favor of speed... until there's a security breach, and then it's already too late.
The securitypocalypse is already here. And I'm not talking about that OpenAI on Huggingface hack. I'll talk about that in another post; suffice to say I don't believe it was a case of LLMs "going rogue" and hacking servers "by themselves".
But I do think LLMs are making 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.
Third, because when you cram a user-facing chatbot into your product, you open your product up to all sorts of prompt-injection attacks.
Fourth, LLMs could also make finding new hacks easier, by automating the searching of existing code-bases for vulnerabilities.
Put all these together, and things could get very bad. "Large parts of the internet become unusable" bad. "Online banking and commerce cease to function" 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.
And that's not even the worst-case scenario! That's if your company is only accidentally making things worse. There are plenty of companies making things worse on purpose. We're decades deep into the enshittification cycle. Software monopolies want you to squeeze even more blood out of their users. They want you to push not just LLM-generated code, but LLM-generated disinfo videos and LLM chatbots onto users, accelerating the breakdown of shared reality, the unusability of the internet etc.
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. (The ultimate scabs!) 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. Maybe it was back when you had a chance of reforming them from the inside, or at least providing a brake on their worst impulses, but I don't think that's possible anymore.
What I think the software job of the future will be like
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 craftsmanship, 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.