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 Download audio 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 syst