AI is removing the middle class of software engineering?

It's not clear to me what "the middle class" is supposed to be here. All engineers exist on some spectrum between "good" and "bad" and it's pointless to try to identify the exact markings, but we all know good engineers and bad engineers.

So AI isn't really doing anything but giving sharper tools to both groups.

So, as it was before, we simply need to set expectations and remove those who cannot adapt and meet expectations... You know, the way it's always been.

So why is AI the problem here?

I told my (small) team of developers that they're free to use anything to get them more productive: (company-provided) AI, black magic, WFH to avoid traffic, etc. But I also tell them that every human (including myself) is responsible for their own (direct/indirect through delegation) work so we can't say "a genie did that, not me". So far it's net positive for us with AI.

I think the worst part is that some companies may be okay with it. They will pay attention only when it's messed up beyond repair. And it’s possible that fixing it will be a task for more advanced models, not humans. Do they win or lose at the end of this martingale? I am not sure

Perhaps more broadly AI will hollow out "middle intelligence".

We could end up with a gulf between those who use AI for cognitive inquiry vs passive delegation. Those who accelerate learning by asking "help me understand this" vs those who relinquish understanding and analytical thinking to AI to complete their work.

It's removing all classes, or at least compressing them towards the bottom.

> In the story above, everyone is failing:

IMO The author fails to list the hypothetical person with 13 PRs to review is also failing.

> * The engineer who refuses to change with the times

IMO many of the old ways of software engineering were local maxima. We're still seeking how to hit a new maxima and the journey may take us through zones lower than the previous local maxima.

Writing code was never the job. Creating value was the job -- coding was just how to implement that goal.

AI generated code is the new "lines of code" metric used by middle management.

Rubbish article, waste of my time.

No confirmation for the title, rubbish arguments and logic.

> Good engineers have become more valuable because AI lets them move much faster.

Bad prediction. This is likely another AI marketing article.

This subheading popped out at me:

> The new AI economy

I don't know if this phrasing is intentional, but it gives me a chuckle. The dotcom boom was called "the new economy" about 26-28 years ago.

Hello

The premise does not make any sense, it is a technical culture problem which you need to enforce. If you let it go wild, yes it will go wilder than ever but this is relatively trivial problem.

There's a more general problem. We need to figure out how to use LLMs and still have decent code quality.

One possibility is to have firmer APIs for known components. APIs that come with the entry and exit conditions for proof of correctness. That gives an LLM a hard definition it can work to meet.

This isn't as bad as it used to be. We may be able to use LLMs to create entry and exit conditions from specs written for humans and from unit tests. Code is cheaper than it used to be, but so is formalism.

This may be a way to put firewalls around AI slop.

It's very true, you used to have to hire people you knew were not very good just to have warm bodies who could throw together widgets, minor bug fixes, etc. You still had to have a competent developer review what they did, which was annoying, but ultimately a time saver over doing it themselves.

Now the competent developer can just run agents and do the same review process, except it's ~free (relative to human salaries, even outsourced).

So we've got a bimodal distribution going on where the bottom X% of developers have become essentially worthless while the top Y% of developers are now more valuable than ever.

This is really well written. I deal with the exact same issues almost daily. Senior engineers who want to guard quality are becoming a bottleneck.

> But what's the problem then? Just use AI to fix it.

Even if that were feasible in a sustainable way (i.e. LLM-generated code wouldn't drown your code base in technical debt over the mid- to long term), the asymptotic end state of this is that the LLM provider owns the means of your production, not you anymore. How can anyone in their right mind run into this obvious trap?

> By the time you've untangled one bad decision, five more have been merged.

And then there's that. What's the value of all this "speed" when it destroys the most valuable thing you have?

> At some point, someone still has to know what is going on. And that's the most valuable person on the team.

The best you can do is see that you keep being one of those.

How can I make myself better, asking as a middle swe

it seems not just the 'middle', but also the 'lower' classes are getting removed

It wasn't that long ago that many were demanding writing code be a required subject in elementary school.

At the same time, it also brings very low level "vibecoder" to the pool

I have a theory that Claude regresses to complexity. It’s trained to mimic existing patterns - so the smallest grain of over-engineering or spaghetti-code is like a mind-virus, gradually infecting all future output and self-amplifying until all is spaghetti.

next, will be sensior engineering

Probably a good thing, we need more people building major mega projects like the Line. Potentially we need AI to mass produce architecture and scale up and out city/county building departments to open the gates to massive buildings in the United States.

All this mindless droning about societal collapse, destruction of jobs, people moving on is really getting old. Sure people have caused mayhem by following (and enforcing) bad practices which resulted in a toxic workplace, a mix of pissed of client due to constantly failing to reach deadlines, unimaginably bad codebase that was a horror to work with and teammates each defending their own turf. LLMs now allow this deterioration to happen much quicker and more effectively.

On the other hand the problem can also be triaged quicker and rewritten faster. Pretty much every startup I joined had at its core disastrous code written by students and overworked techies. I can totally see this shitty base being the future base all startups. It'll likely need an army of agents or devs to make sense of all the spaghetti being written. I won't be surprised if demand for devs skyrockets after the first generation of spaghetti western code "matures".

Great idea to include a link to Hacker News on your blog!

"You can't afford bad engineers anymore"

You never could.

Agree with the article, but good luck convincing upper management about it.

“If it works, don’t fix it” until it doesn’t and we shall see a new wave of software hiring in a year or two.

Every enterprise is talking about AI Transformation, and that great with the right expectations. But those who think AI will just make platforms quick with less people and least experienced engineers, will have to prepare for the deinshitification transformation in a year or two.

> bad engineers were always a liability

So. AI Makes good engineers better, more productive and able to deliver well designed systems.

But it makes the bad engineers 10x worse. Before, they had negative productivity in a team environment. Now, its 10x negative productivity. The mess they create as one person might need 10 people (and their AI's) to clean up.

I would also put people who don't know how to code in that bad engineer basket. They would be delivering code they don't understand, accepting unnecessary complexity etc just like your standard bad engineer.

maybe the middle class never belonged there to begin with ?

In the words of Admiral Ackbar, "It's a trap".

Any apparent short term gain is really a prescription for long term pain.

Ignore what AI fanboys say and instead look at what they do.

https://northeasttimes.com/2026/08/07/oracle-bans-ai-code-fr...

hahah this is all well and good until the 20k+ line a day person is considered the good engineer, based on kpis alone. Your VPs aren't reading any of that.

Bonne chance fired senior!

I have depicted you as the 100 line a day weakling, and myself as the 20k+ line chad.

The systems at bigcos are too ruthless to risk gambling your career on this kind of reasoning which you have no recourse to. Best to start small teams and destroy them from the outside.

To the headline: Yep, and for false reasons they'll have to pay for later, alas.

More like AI is exposing bad engineers faster than it would've been possible earlier. Previously they would simply outsource all their thinking to someone else, now they see massive progress with AI and delude themselves into wishful competence.

I work in software and I wonder what companies are letting in those 25k line PRs? If I change more than 3 files at once that's already rising a sea of eyebrows and it will be a week or more to get it through code review. I can't even imagine what kind of supernatural circumstance would lead to anyone accepting a 25k PR at all.

"There are also people who essentially make it harder for everyone else. And now anyone can produce more code in a day than they used to in a year."

That is the "democratization" that AI shills speak of:

https://xcancel.com/dhh/status/2087538364580835804#m

Once a CEO with a snowboard-optimized brain gave you a board seat, there is no way back.

As an open source maintainer, I can chime in on this.

With TxtAI, I've seen a large uptick in PRs (https://github.com/neuml/txtai/pulls?q=is%3Apr+is%3Aclosed+s...). While the extreme verbosity of Claude messages and commits is very annoying (plus the constant defending itself on why it's a bug), I do think it's a positive that more people are enabled.

It does require reviewing the PRs. Some can be tricky just like a human. For example I did merge this PR (https://github.com/neuml/txtai/pull/1136) and it would have completely broke search. But a human could also do that.

From an open source standpoint, I say the more the better. You just have to be willing to do the work to review and no not just having AI agents to review what the AI agents are submitting. There still needs to be a human in the loop, if you care about quality.

While there are bad engineers, I imagine that teams that have evolved alongside AI and have maintained their size and consistency without adjustment may have structural issues. I would argue that team size counts ought to be smaller now than before Claude. Unfortunately this idea could feed an AI-induced layoff trend, but it could instead lead to product diversification instead.

I'm not sure what skill really means, or what's considered bad anymore. AI coding ability and human coding ability are different, and different organizations need different skills. No skill is inherently bad—it just depends on what the organization needs.

I understand that AI writes better code than people like me in many cases. But an industry should still provide opportunities for those people. And sometimes those people create things that are better than AI in certain areas. The problem is when even those opportunities are taken away.

Ai isn't removing the middle class of software engineering.

Software engineering is evolving, and the middle class (and beginner) is going to have to grow instead of being able to leverage the same skills for longer and longer.

It's so true from some of the other posts that you can outsource your thinking, but you should never outsource your learning and understanding.

This is why I think if you are need a 20x plan to code/do software engineering, there is no way you will read most of it, and it is likely 100% slop. A rare few can use it and not create a mountain of tech debt in a few days of use.

Very good article.

But it does cover the case where someone makes it to the top if he/she is junior. Who experience is gained?

Maybe I ask too much from a short article.

> But once you start storing data there, you can't just remove them. You have to come up with a migration plan, make sure you don't disrupt the system because people are paying to use this every day. You have to think about what you'll do if the migration fails. Make sure you don't end up with orphaned foreign keys. It's just so much harder to fix. Even with the best model you can get.

Migration plan? Just ask Claude when shit hits the fan. You'll make a plan when you need one.

> By the time you've untangled one bad decision, five more have been merged.

I'm slowly (partially ironically/sardonically/nihilistically) adopting a mindset of accelerationism towards the collapse of software development - it was largely done wrong from day 1 and wasn't "real engineering" to a sufficient degree to not lead to the mess that we've been in maybe for the past 20-40 years. The only thing AI did was take away the brakes and press down on the accelerator, we're already headed towards a cliff and have been for a long time.

If the code in airplanes and spaceships was developed with the same degree of care and attention as "good code", you'd see those dropping out of the sky regularly. If they built bridges like we build software, they'd fall apart regularly as well. Good code CANNOT hinge on the opinions of some senior dev, or even a group of them - it must be provably good. And if it must be provable, then these checks must be automatable. Bad code (whatever that means, however you'd manage to classify the difference between AI slop and what you want to see) should be IMPOSSIBLE to get into the system at all, due to those automated checks.

Be it good enough test coverage, automated checks for usability and end to end coverage of the features, project/domain specific lists of architectural rules (think ArchUnit), needing proofs not just tests etc. We will never have that - our OSes are bad, our browsers and other essential software is bad, our programming languages are bad (the fact that unchecked exceptions even exist in languages is a cardinal sin), same for databases and tbh any other class of software you can look at.

This impassioned comment might border on a rant, but my argument is that the past decades aren't the baseline of good code, we'd probably need to spend 10-100x more effort to produce 100-10x less code, but make the existing code bulletproof - there is no reason for more than one OS to exist, no reason for more than one UI framework to exist (or even all of the egregious ways how the web platform was transformed from documents and links to a collection of badly written apps, which eventually infected the desktop with Electron, due to the native GUI development also being severely neglected), no reason for more than one web framework to exist or even more than one programming language to exist in mainstream usage outside of research and looking for the solution to use for the next decade/century of software development. Yes, I'm exaggerating, but the correct answer is probably closer to 1 than to 1000.

Obviously that'd lead to death by comittee and some degree of experimentation is necessary, so hey we end up with a new slopped together library every week and I know nothing and nothing works anyways. I wonder if we had ONE high level programming language, whether over time it would have evolved from C++ to Rust (sans odd parallelism), and if it was based on formal proofs, then migrating between language features could have also been fully automated, alongside enough pushback to any feature deemed not worth it. On the other hand, even with all of the world's developers concentrating effort, something like that might be above our cognitive abilities, so probably not - just too hard to reason abuot.

A pattern I have noticed is you get way better results if you just have one skilled senior engineer coding everything with AI vs a lot of people.

Having large teams in the age of AI is pointless. It slows things down and spreads accountability too thin.

When you have one good engineer doing many things, a lot of stuff lives in their head and they know what to look for in their own PRs. Also, people tend to like their own AI slop, but not others. So overall you will have at least an engineer who is satisfied with the codebase vs a lot of people who either have some gripe about something someone else did, or just don’t care at all.

That means you have to put way more trust in a single individual, but if it’s the right individual you propel the organization further ahead than a team of mediocre engineers or senior engineers limited in what they can accomplish.

This blog conflates productivity with expertise.

Are LLMs rewarding experienced developers with tons of productivity gains? Yes.

Are LLMs actively degrading their expertise of understanding code? Also yes.

This article has made the implicit assumption that the top quartile of engineers are immune from skill decline. They're not. If you're an engineer who increasingly outsources the planning, writing, and analysis of code to an LLM, you're losing your ability to plan, write, and analyze code.

All of this is to say--senior engineers who have fully adopted AI tools are blowing smoke up their asses to dodge the reality of their own obsolescence. The senior engineers can talk about productivity all day, but they're only marginally closer to understanding a complex system that was written by LLMs than the "middle class" of engineers are.

You reading this--yes you--get over yourself. Your skills are depreciating too.

Wait till we realize that nobody is buying the software we vibe code anyway.

We've seen this game before, with the Dot Bomb and 9/11. A lot of you have 6 figure jobs that will simply be gone next year after the election, never to return.

That winter lasted about 5 years until 2007 when the iPhone and social media sites like Facebook went mainstream. This winter won't end. Or more accurately, it is the end.

Maybe we should stop debating whether we're in a crisis and start looking at the 5-10 year endgame of the Singularity. We're entering the eventuality that many of us have predicted since the arrival of the internet 30+ years ago, that prices will get lower but nobody will have any money to buy anything anyway. The feeling that we're doing something wrong with our lives will continue to intensify. We'll try so hard, and get so far, but in the end, it doesn't even matter.

I don't know about the rest of you, but I'm turning my attention away from trying to play the job game with AI. I'm looking instead at how we can provide time/money/resources to the middle class after capitalism can no longer provide them.

A conservative friend of mine just read the Communist Manifesto by Karl Marx, which I didn't see coming, especially since he beat me to it. In the neurodivergent spirit of not being able to do anything alone, what if we all read it?

https://oll.libertyfund.org/pages/marx-manifesto

https://www.marxists.org/archive/marx/works/download/pdf/Man...

I'm predicting that it stops just short of what full automation can provide. Loosely the evolution of economics goes: hunter-gatherer -> agrarian- > feudalist -> capitalist -> socialist -> communist. And now solarpunk (or something).

The working class is looking forward to the next chapter, but the capitalist class is looking backward to neofeudalism.

Those two directions can't coexist, so what does the future hold? Well, it's always darkest before dawn:

"It's easier to imagine the end of the world than the end of capitalism." - Mark Fisher.

https://www.youtube.com/watch?v=aCgkLICTskQ Mark Fisher: The Slow Cancellation of the Future

https://www.scribd.com/document/835022535/Mark-Fisher-The-Sl... (transcript)

https://goodscienceproject.org/articles/the-slow-cancellatio...

https://mediationsjournal.org/articles/end-of-world

If the endgame of capitalism is that it inevitably eats itself, then the game now isn't how to get more money and do nothing with it, but instead how to start doing something with no money.

I should add that even if I'm exploring anti-capitalist futures, that doesn't make me socialist. I don't like the 6 hour daily work requirement of many socialist societies. I think we can do better than that and get closer to 0, so that we can shrug off wage slavery and finally get real work done.

[dead]

AI gives more leverage to exceptional people, its an amplifier not an extender

Economics would have always created this downward pressure on demand for software engineers regardless, either companies would replace the number of engineers they need with AI, or with low paid offshored workers.