Newshot

AI might be the end of our careers

Original text(via HN AI)

‘AI’ might be the end of our careers

I never planned on becoming a software developer, and these days it feels like my exit from the industry might be similarly unplanned.

The video version is on YouTube.

图表:‘AI’ might be the end of our careers

Shifts in power

My education and training is entirely in art, literature, and media. Like many of my generation I got into web development because it was, quite simply, one of the more interesting things happening in the late nineties that a young person could get into without a big investment.

Web and software development turned out to be a decent job with decent pay. Even with my tendency to work for charities, publishers, and cash-strapped media outfits, dev work has always been a steady gig that paid okay.

But I’m increasingly concerned that the future might be quite dire for software development as a profession in the long term, even beyond the current era of bubble mania. The prospects of software development as a field and as a career are inversely proportional to the success of Large Language Models in coding.

A new kind of unskilled labour

Here’s a hypothetical example – loosely based on several real-world examples I’ve witnessed.

You have a software company, or organisation doing the kind of work that requires a small software team of mixed specialities. There are server-side developers who write in Ruby, or something similar, and front-end developers who understand the node runtime well enough fit under the otherwise vague and meaningless label of “full stack”.

After a recent wave of layoffs, the front-end team is short-staffed, so the Ruby team steps in to work on some of the front-end tasks as needed.

Sometimes it’s the other way around, but in this example it’s Ruby devs doing JavaScript.

They don’t know the first thing about web development, DOM APIs, the CSS cascade, or any of the fundamentals that make web development unique. But they aren’t worried. They’re using “agentic development” and the agent generates code in whatever language you want. As far as the business is concerned, these developers don’t need to understand any of the fundamentals, they just need to work from the requirements and understand the general structure.

The output of the agents is neither great nor catastrophic, at least to begin with. It has issues, mostly down to performance and reliability but neither of those concerns have been dealbreakers in software for over a decade. The industry is perfectly fine with products that are constantly partially broken.

The company talks up the productivity gains of generating code, without actually checking to see if those gains are realised in concrete ways, and hype up the flexibility of being able to shift developer staff as needed.

Nobody seems to have actually noticed what happened, which is that skilled specialised labour has been replaced by less skilled, less specialised labour.

This isn’t a value judgement. I love Ruby. It’s a lot of fun. But server-side Ruby and client-side JavaScript are already very different specialities even without taking accessibility, HTML, CSS, and other client-side concerns into account.

What happened is that “AI” let the company replace a specialist with a non-specialist.

Or, phrased a bit differently: automation let unskilled labour take the job of skilled labour.

We’re seeing this happen in other ways as well. Managers, support staff, and designers are all “prompting” code and committing changes to projects and products.

These are literal examples of people who are unskilled in a specific specialised job but are doing the work of a specialist with the help of automation.

We’ve seen this happen before in history – it has been happening since the dawn of industrialisation – but I don’t think we’ve seen many examples as extreme as what’s happening in software. What’s especially unusual is how eager software developers have been to promote the tools that are effectively ending our own careers.

That might be because it’s not always obvious why it’s bad or how specifically it’s going to end our careers. The reasons why this is very bad for software developers and our field can be a bit counter-intuitive.

Most people’s expectation of the technology is that as long as “AI” falls short of the full automation that requires general purpose reasoning, it won’t be able to fully replace developers, and as long as it doesn’t replace us directly, it won’t harm our job prospects.

That the code genuinely – at least from the perspective of third party observers – seems to be of a lower average quality than code written by hand, and gets less and less accessible as the layers of generated code pile on, further supports the idea that even though this might be a change in our practices, companies are still going to need us.

This might be true, but what it misses is that, in the long term, they won’t have to pay us as much as they used to.

The biggest threat “AI” poses to software developers isn’t that it might replace us, it’s that it will let our employers redefine our job as more generic, lower paid, and unskilled.

Or, less skilled at least.

Supply and demand

If, like me, you spent your teens and college years working to pay for your education, you’re going to be familiar with how limited your job options are when you’re young, unskilled, and inexperienced.

Most of the jobs you have a shot at – unless you’re some sort of nepo-baby – are unskilled labour. That means the employer believes the job doesn’t require any expertise, experience, or skill to perform.

What that really means it that the employer thinks you’re perfectly replaceable. They believe there is, in economic terms, an infinite supply of potential replacements to take your place each as good as the other.

It doesn’t matter if the job actually is unskilled or not. I very occasionally stepped in as a substitute bartender at a hotel during college[1] and there is obviously a huge difference between a skilled bartender and an unskilled one, but both of us got paid the same.

Because the job is classed as “unskilled” and the supply of possible replacement is near infinite, you don’t have any leverage or bargaining power. That means the employer gets away with paying you whatever the legal minimum is for that job in your country.

The formula is simple: the less skill the job requires or is seen to require, and the greater the supply there is of replacement workers, the less the job will pay in the long run.

“Unskilled” office work, such as that done by agency temps, gets paid much less than PR, sales, or marketing.

Skill levels and supply of labour are two of the main reasons why I’m worried about the prospects of software development as a career.

Deskilling began a long time ago

The drive to turn software development into less skilled labour isn’t new. Not to be confused with attempts to make the craft more accessible and approachable, deskilling generally focuses on making the developer conform and aims to limit what they need to know to do their jobs.

Before “AI” the biggest push in this direction was the adoption of web development frameworks such as React – a framework for building web and native apps, if you aren’t familiar. React wasn’t popular because it made for better software but because it simplified recruitment by deskilling the job. You need fewer skills for framework-oriented web development than for a job that requires understanding the front-end stack in its entirety.

  • You didn’t have to understand the platforms you were building on.
  • You didn’t have to understand the languages except how they operated in the limited context of the framework.
  • You didn’t have to understand the context of the work you did. Components were designed for the purpose of making labour interchangeable between teams and departments, not to separate concerns or optimally structure the software.

Companies loved React not because it cut costs or increased productivity. They loved it because it promised to simplify recruitment and let them hire developers with less training. It promised them a world where bootcamp trainees would, after only a few weeks, be able to perform as well as a computer science graduate or somebody who had worked with the web since before frameworks existed.

The bootcamp graduates would be paid less, obviously, but at the time the concern of most employers was primarily to offset the massive imbalance that existed in the software developer job market at the time: the demand for developers far outstripped the supply.

The bootcamp promise never really panned out, which is why many of those outfits devolved into fraud and scams, but it shows us that employers have been interested in the idea of deskilling the job since well before coding agents became a thing.

Two things have changed:

  • Demand for software developers turned out to have been artificially inflated by tax loopholes, low interest rates, and a very irrational belief in the long term sustainability of the software industry’s massive growth rate.
  • The supply of software development labour has now increased dramatically. LLM tools have placed an ever-increasing number of people who are unskilled in software development in direct competition with us, the skilled developers. The layoffs have also increased the supply of unemployed developers with experience who are competing for every available job.

Demand deflation

Whatever the reason, employers today almost universally believe they need fewer developers.

Pretty much every company, small and large, that employs software developers has been scaling back on the number of coders they employ. They all believe they’ve massively over-hired.

That means there is less demand.

There’s also the increasingly common sentiment that regular software is basically done. That operating systems and productivity software are basically already as good as they get, already at market saturation, and the only true growth opportunity is pushing “AI” onto as many people as possible.

This further depresses demand for software developers, especially those who are specialised in user-facing software.

Regulatory efforts to tackle oligopolies, monopolies, and abusive business models have also stalled. Oligopolies and monopolies generally don’t need to do anything to make money, so they don’t really need to be hiring as many people as a company in a more competitive market would.

That’s even less demand.

All of this is happening regardless of “AI” and it’s likely that when the financial bubble surrounding “AI” pops, demand for developers will be pushed down even further.

Junior hiring is over

That lack of demand has hit new Computer Science graduates hard. The current software developer job market is bad for everybody, but for new graduates it means they won’t have the opportunity to start a career in their chosen profession.

Most of them will end up pursuing other careers. Some of them will discover, through happy accidents, that they have a different calling in life. Many won’t care that much because what matters is putting food on the table.

But those who are enthusiastic for the field will feel betrayed – lied to – and are unlikely to forgive the industry if the situation changes in the future.

This too has happened before, and normally it results in a long term cycle of dysfunction.

It usually begins as the job market for a speciality deteriorates, graduates in that field go unemployed, course attendance declines, the number of graduates collapse, and that industry is saddled with an ageing workforce. Managers think this is fine as they just see the cost savings of not having to train new employees that they won’t need.

Several years later, the industry experiences a growth spurt again, but that growth is stalled from the outset because there is no supply of labour to fuel it. There is no one to hire to fill the increased demand. Short-sightedness killed off economic growth.

The problem we’re facing as a profession is that “AI” breaks this cycle for software developers, to the company’s benefit and our detriment.

When the time comes for the software industry to experience its first post-bubble growth, companies won’t be limited to hiring what ever new graduates are available at the time.

Employers will be able to hire as many unskilled, untrained, low-wage office workers they want, saddle them with whatever shoddy agentic coding tools are available at the time, and set them to work.

We’ve created our own competition and destroyed our bargaining power in the job market.

Unskilled software development

People with no skill or expertise in programming have entered into direct competition with those of us with expertise.

We’re all seeing unskilled software development eat into our business, one way or another. Managers and designers are vibe-coding software. Clients send us half-baked vibed up code they want us to finish. Developers are vibe-coding in languages and on platforms they’re completely unfamiliar with. A bigoted ruby programmer who is vibe-coding in rust is effectively an unskilled worker replacing a skilled one through the use of automation.

Some of this is also happening in the software marketplace itself. One example I’ve been keeping track of is a writing app, because it’s quite illustrative is Neo.

Hugh Howey, who is an author and not a programmer, has been vibe-coding his own writing app. It’s basically a remix of preexisting open source writing tools with no attribution, because that’s how LLMs work, all wrapped up in Howey’s preferred user interface themes and style.

The number of apps and games released onto the various online marketplaces has exploded. Sales have not followed suit. Very few of these kludges are bought by anybody and quite a few, like Neo, are offered for free.

The last time something like this happened was during the mobile app store bubble.

A glut inevitably changes consumer value perception, the price you can demand for software craters, and the clutter makes it harder for well-made apps to succeed.

Together, increased supply and less demand has a very simple and straightforward consequence: lower prices everywhere.

This is going to be the case no matter how the “AI” bubble pans out. A collapse might make it financially infeasible to train new models from scratch, but the financial rewards for companies if they manage to depress software developer wages are substantial enough to offset higher running costs.

And if we aren’t creating any new handwritten code to speak of anyway, because the industry has switched entirely to vibe-coding, the rewards for training new models from scratch would be minimal at best. There isn’t really any new code.

Software developers are generally paid much more than illustrators or photographers. Modern companies employ more of them, even after several years of regular layoffs. Even if “AI” code turns out to be mostly garbage, the software industry has a long history of being genuinely tolerant of garbage code and garbage designs.

There is no path forward for “AI”-generated code that’s a net benefit to us, software developers, as a profession.

  • If these tools increase productivity, that just adds to the problem because that will just depress demand for developers even further.
  • If it decreases productivity – once you account for how works flows through the entire system – then existing software developer pay is high enough to still make that productivity sacrifice extremely lucrative.
  • If it generates code that’s as good as that of a mid-career developer, then that just makes it easier to quickly “gear up” relatively unskilled people to step into specialised software development jobs for less pay.
  • If it constantly generates unsafe code, then it’s still worthwhile because the financial cost of even major software defects are relatively minor in the markets while the benefit of paying developers less is substantial.

No matter how this plays out, as long as “AI”-generated code continues to be accepted, we as software developers lose.

The more supply of labour and less demand there is, the lower the pay, and less employment there is.

The supply-demand equation

If there’s less demand for software developers, our pay is likely to decline over time.

If there’s more supply of people able to do software development work, then that pushes pay down even further.

If software development, or specific subtypes such as web dev, gets redefined in the marketplace as “unskilled”[2], then we lose our bargaining power in the job market and pay gets pushed down even more.

Jobs where labour has less bargaining power get a smaller cut of overall revenue, which means that if things turn around after the bubble pops, the jobs that have been deskilled and redefined as “unskilled” won’t benefit from that turnaround.

The best we can hope for, as software developers, is that agentic coding turns out to be completely unviable after the financial bubble pops and that most of these tools just outright disappear.

Because if it remains even partially viable in the long term, the push to redefine larger sectors of software development as unskilled or semiskilled will continue. This will cause our ability to demand fair payment for our work to crater.

Some parts of software development will probably be sheltered from this, but it’s hard to tell in advance which will and which won’t.

What can we do?

Software developers as an expertise or field of practice does not stand to gain from “AI” in any meaningful way. The success of “AI” would mean that most of our careers have reached an end station and the field will enter a steady decline.

This is fine if you’ve already got yours, if you’ve already cashed in on stock options, or have already saved enough for an early retirement.

This sucks if you actually like the job.

More than any other profession, due to widespread adoption, pervasive belief in its effectiveness, and broad support from employers, software developers are the ones who stand to lose the most from the success of “AI”. But we can pick up some of the tactics used by some of the other fields affected by “AI”-driven job losses.

It’s common now among illustrators and writers, for example, to basically make the use of “AI” socially unacceptable. Individuals with bargaining power, such as John Scalzi require that the work done on their books by their publishers be done by humans without the use of generative models. Antipathy towards “AI” is increasingly popular among both those who work in the creative industries and those who are fans of that work.

The more “AI”-free corners of the field software development we can protect, the stronger our bargaining position becomes as software development workers. Pushing “AI” out of our field where we can is one of the strongest, most effective tools we have for protecting our field from being devalued.

People who use their public profile, influence, and platform to promote the use of “AI” for coding should feel defensive. They are actively undermining our careers. We have a right to be concerned about their actions.

That isn’t to say that people should be aggressive, abusive, or violent. Quite a few people are just doing what they can under difficult circumstances to put food on their table or keep themselves employed. We don’t know what’s going on in people’s lives, and we don’t know what might motivate people to use these tools.

But criticism, even harsh criticism, is legitimate when somebody with a large public platform, or strong influence within the industry, has picked a side against our profession’s best interests.

A solo developer working in relative obscurity on their open source project is not in the same position as Linus Torvalds and should not be made to be a target. But Linus has picked a side, and it’s not our side.

The more “AI” becomes a sales and marketing liability across multiple industries, the stronger our position will be.

The more of a political liability “AI” support becomes, the more likely we are to get regulation and enforcement that limits the harm done by the tech.

The broad basket of technologies that the industry has marketed as “AI” is shaping up to be the least popular in the history of computing.

It still has fans, but nothing in computing comes close to being as disliked by as many as generative models are today.

If we build on that, there’s a chance that software development will continue to be a viable career into the future.

  • I was working as a night manager and, at that very shitty hotel, when somebody called in sick the night manager ofte had to step in. ↩︎
  • This has happened before with CSS, for example. CSS work used to be a speciality within web development but later got effectively re-classed as “unskilled”. ↩︎
  • Previous entry Automation, algorithms, and self-censorship 5 November 2026

The text above was extracted automatically from the source page and may miss images, tables or code blocks. The original is authoritative.

Published by HN AI
This site only summarises and aggregates; copyright stays with the original author. Headlines and summaries follow the source — where they differ, the original wins.
Read the original ↗