Software engineers have had a suspiciously good run.

For the better part of two decades, the profession offered a combination that was difficult to find elsewhere: high salaries, generous benefits and offices whose interior designers had apparently been briefed to build playgrounds for adults. You didn't necessarily need a degree, rarely needed a suit and, eventually, didn't even need to leave your bedroom. While teachers, nurses and other highly trained professionals continued doing their vital jobs for considerably less money, we were arguing about whether the free office lunch had enough vegan options.

We didn't exactly handle our good fortune with discretion. We took on absurd names: rockstars, ninjas and gurus. We built an entire culture around the idea that software was eating the world. Every industry was ripe for disruption, every profession was inefficient and every problem could be solved by putting it behind an app and a monthly subscription. There was always a little irony in hearing people with some of the most comfortable jobs in the economy explain why everybody else's was about to disappear.

Now software is supposedly coming for ours.

Everyone can code

Coding bootcamps promised to democratise software development.

For years, the proposition was difficult to resist. Take a few months off, learn a programming language, build an app and emerge into a new economic class with a company MacBook and a salary your previous profession might have required a decade to reach. Software engineering became a promised land that required neither years of university nor professional accreditation to enter. You just needed to learn to code.

It was probably unreasonable to expect them not to bring popcorn when it finally came for ours.

Except there was an awkward contradiction at the heart of the sales pitch. Software engineers were supposedly paid so well because they possessed scarce and specialised skills, while an entire industry was simultaneously advertising those skills as something almost anyone could acquire in twelve weeks. Coding was valuable enough to transform your life, but easy enough to learn before you had to stow away your winter wardrobe.

Amid the wave of tech optimism, the contradiction didn't matter. Tech was growing quickly enough to absorb an extraordinary number of people. The bootcamp era helped cement an idea that survives today: that software engineering is primarily the act of writing code. Learn enough syntax, memorise a few snippets, internalise some jargon and you're more than welcome in the secret society.

Alas, the market became less forgiving. Bootcamp graduates discovered that building a book-search application and being entrusted with a production system were not quite the same thing. The twelve-week programme ended, but for many the promised career never began. The gates to tech had been advertised as wide open; there was still, inconveniently, a gate, with keepers guarding it.

Nobody needs to code

If bootcamps promised that everyone could become a programmer, no-code offered something even more attractive: nobody needed to become one.

The databases became colourful boxes, business logic morphed into unidirectional arrows and websites could be assembled by dragging rectangles around a screen. The objective was no longer to teach the rest of the world the strange rituals of software development, but to remove the software developer from the process altogether.

There were valid reasons behind this promise. Engineers had become accidental gatekeepers to an increasingly digital economy. If you had an amazing idea for a product, somebody eventually had to translate it into code and ship it. If marketing wanted to experiment, engineering had to build it. If product wanted a feature, engineering had to estimate it. If designers wanted a button moved two pixels to the left, engineering had the audacity to ask why.

Democratising the means of production doesn’t necessarily mean democratising the returns.

Crafting software gave engineers leverage well beyond the mechanical keyboard. The skill was scarce, demand was high and companies increasingly depended on it. In Marxist terms, which is obviously where any sensible discussion about developers eventually ends up, software engineers had acquired control over a small but increasingly important means of production.

No-code tried to loosen that control, but failed to deliver the seismic change it promised. A bigger shake-up was cooking.

Seize the means of production

AI isn't being sold merely as the next evolution in software production. Increasingly, it is touted as a liberation from the people who know how to write it.

A three-month coding bootcamp is now twelve weeks too long. A deep understanding of programming is superfluous. Hiring a team of opinionated software engineers is a threat to the balance sheet.

The revolution is underway. It comes with a monthly subscription, per-seat pricing and token allocations. It has its thought leaders, warriors and propaganda department. No blood is being spilled on the streets, but the transformation is violent nonetheless.

The masses are shouting "Expropriate!" and software engineers are feeling threatened. Skills acquired over decades are turning into commodities anyone can claim. Their power within organisations is being dismantled. Their pride in the craft, their achievements and even their passion for it are increasingly recast as arrogance and resistance to progress. Public executions are, thankfully, not part of the manifesto, but the software engineer's character assassination is high on the list.

Schadenfreude as a service

A serious technological transformation is taking place. Denying its existence or impact would be about as useful as insisting the internet was a fad in 1998. But technology alone doesn't explain the peculiar enthusiasm surroundingthe upheaval in software development.

Every profession worries about progress, mechanisation and automation. From factory workers to horse-carriage drivers, the past few centuries are brimming with examples of technologies that disrupted entire industries and livelihoods. The angst around major milestones, such as the Industrial Revolution, also led to unrest, revolts and unprecedented social and political mutations.

No matter where you stand on the ideological spectrum, it's hard to deny that one of humanity's biggest struggles has been that between those who have and those who don't, those who exploit and those who are exploited, those who control the means of production and those who are but cogs in the machinery.

Unless you've achieved absolute enlightenment and completely detached yourself from material possessions, it's hard to argue that envy or jealousy aren't features of the human experience. From biblical tales to wars, we've always wanted more, especially when someone else has more.

Watching tech workers enjoy salaries and working conditions that seemed wildly disproportionate from the outside didn't go down well with everybody. Study for years, work in an essential profession and commute every morning, only to find yourself earning half as much as someone in their twenties writing code from their kitchen table. No need to harbour a deep hatred of programmers to wonder whether the labour market went haywire.

Then there are those who tried to join the party. They learned to code because an industry told them they could, only to be stopped at the door. And plenty never wanted to become programmers at all, but spent twenty years listening to tech explain how software would disrupt their jobs, their industries and occasionally their entire way of life.

There is something satisfyingly symmetrical about watching the disruptors get disrupted. It would be reductive to call that jealousy. It would be equally naive to pretend there isn't a little bit of it in the room.

The call is coming from inside the house

From inside the office, to be precise.

The line dividing the revolutionaries and their "victims" might seem very clear at first. But painting the skirmish as non-techies versus techies is too reductive. Some "techies" have answered the call to arms.

Software companies have spent years creating their own non-technical class: people who came from engineering but gradually moved high enough that software became something they manage instead of make. CTOs, VPs of Engineering, directors and their directors can still be deeply knowledgeable about technology, but their relationship with it has fundamentally shifted. Their work revolves around strategy, budgets, headcount, roadmaps, hiring plans and organisational problems rather than commits, builds and deployments.

From their perspective, the distinction between software produced by twenty humans and software produced by five humans with AI can look mostly like a question of efficiency. Requirements enter one side of the organisation and software emerges on users' screens at the other. What happens in between is an implementation detail, and implementation details are precisely what this class of workers doesn't typically worry about.

There is also a comforting assumption hiding in that view: the machinery can change while the human overseeing it remains necessary. Replace programmers with agents, reduce the assembly-line headcount, increase output and report the efficiency gains upwards. The factory gets automated and management continues managing, for now.

This creates a curious coalition between two seemingly unrelated groups: the people who never learned to program and executives who haven't shipped production code in years. They might look at AI from opposite ends of the org chart and still reach roughly the same conclusion: at last, we don't need so many engineers!

They may both want to be careful about where that story ends.

If AI can understand a vaguely specified product requirement, break it into tasks, coordinate agents, evaluate their output and report on the result, the boundary between replaceable technical work and irreplaceable management work starts looking suspiciously arbitrary.

Revolutions, after all, are notoriously bad at respecting org charts.

The job was never the code

There is a more fundamental problem with the promised abolition of the programmer: it depends on the same misconception the bootcamp era helped create.

Bootcamps claimed that because coding could be learned quickly, anyone could become a software engineer. The loudest AI advocates now tell us that because code can be generated quickly, software engineers are no longer necessary. The conclusions point in opposite directions, but both reduce engineers to producers of code.

Code is certainly part of the job. It is also increasingly the cheap part.

The expensive parts tend to gather around it: figuring out what needs to be built when nobody agrees, understanding a system whose original authors left five years ago, choosing between solutions with hidden trade-offs, keeping old software alive while replacing it, investigating the production failure that cannot be reproduced locally, and eventually taking responsibility when software meets the untidy world outside the text editor and the deployment pipeline.

Machines will get better at those things too. Some will be automated entirely. The point isn't that engineering possesses some mystical human quality that machines can never reproduce. But making code dramatically cheaper to produce doesn't force the rest of software development to disappear with it.

Meet the new bourgeoisie

There is one final inconvenience with our revolution: nobody actually seized the means of production.

We rented them.

The models capable of democratising software require extraordinary amounts of compute, infrastructure, data and capital. The factories haven't been handed to the workers; a proprietary API has been placed in front of them, its access and price controlled by a board of executives in an opulent office.

The person who couldn't build software yesterday can now create things that once required an engineering team, which is genuinely remarkable. They can also lose that ability when the subscription expires, their account gets suspended or their provider's status page turns red.

Let them eat tokens

Software engineers may indeed be losing their position as gatekeepers of digital production. Millions more people may be able to make software without ever learning what a function is, and civilisation will somehow continue. Engineers themselves could become dramatically more productive, with smaller teams building things that once required entire companies.

Or perhaps one engineer will simply be expected to do the work of five while the savings travel elsewhere.

That's the part of the revolution we haven't figured out yet. We spend a lot of time asking whether AI can replace programmers and considerably less asking who captures the value when it does. Democratising the means of production doesn't necessarily mean democratising the returns.

For now, the software-engineering bourgeoisie can enjoy the historical irony. We spent twenty years telling everyone that technology was coming for their jobs. It was probably unreasonable to expect them not to bring popcorn when it finally came for ours.