Over the past few months, the headlines have been telling us that software engineering is dying, yet the hiring figures are telling us that senior engineers have never been scarcer or better paid. How can both things be true, or is there something missing from either side of the argument?
I started digging into that contradiction because it's related to my own field of work, and the closer I looked, the less it had to do with software specifically. The same divide shows up wherever AI is involved with a role.
It comes down to one question, and it isn't the one the headlines are asking.
The wrong lens
The standard way to talk about AI and jobs is to rank occupations by "AI exposure": how much of a role a model could, in theory, do.
Unsurprisingly, this has produced a lot of headlines about jobs at risk from AI. It has also produced headlines that flatly contradict each other about the same jobs. Some analysts read a high exposure score as good news: more of the day-to-day work gets automated, so the role becomes more productive and better paid. Others read the identical score as a warning: the more of a job that can be automated, the more of it will be.
Same input, opposite conclusions: that's usually a sign the input is missing something. Software engineering scores high on every exposure ranking, and that score is compatible with both the "dying profession" headlines and the senior hiring boom. A measure that can't tell those two outcomes apart isn't the right lens.
Generation vs verification
AI is very good at generation: a first draft of a document, a block of code, a shortlist of candidates, a first pass at a contract. But it isn't yet trusted (and arguably not yet able) to make the call on whether that output is safe, correct, or good enough to use. Ultimately, someone has to be responsible for that decision.
Another way to think about it is as two different bottlenecks:
- Generation bottleneck: not enough drafts, not enough code, not enough throughput. Output is the constraint.
- Verification bottleneck: plenty of output, but someone still has to decide whether to trust it. Judgement is the constraint.
When AI is involved, it typically removes the generation constraint, and the verification one is what's left:
- Anyone with a coding tool can produce a lot of plausible-looking code, fast
- But that says nothing about whether they can spot when it's subtly wrong
The catch is that verifying AI output, in any domain you don't already understand, is genuinely difficult: AI failures tend to look confident and unremarkable right up until they aren't.
That said, not every judgement call needs a person. It comes down to two questions:
- Is this situation unusual?
- Is the cost of a mistake already known?
If the situation is unusual and the cost of a mistake isn't known yet, a person has to make the call. If it's routine and the cost is already known, you can automate the whole thing.
Figure 1: A judgement call stays with a person when the situation is unusual and the cost of a mistake isn't known in advance.
Economists Agrawal, Gans and Goldfarb found something further about this division of labour: automating a task can make the human judgement that's left over more valuable, not less. They call it the "Turing Transformation."
That's why the verification constraint doesn't get cheaper just because generation got faster. The judgement itself is increasingly for catching a wrong answer, not finding a better one. Nobody pays a senior person to write a cleverer line of code or a more creative set of accounts; they pay them to catch the one that breaks in production, or the one that's wrong.
And this isn't only a software story. PwC's 2026 Global AI Jobs Barometer, which looked at more than a billion job ads across 27 countries, split AI-exposed roles into two groups: ones where AI takes the routine work and leaves judgement with a human, and ones where AI mostly lowers the skill bar for people without deep expertise. The first group is growing twice as fast, with 42% faster salary growth.
Software engineering is useful here for a more specific reason: both of those things are happening inside the same job title at the same time.
- Generation: more people can produce code with AI tools, faster than before.
- Verification: the people who can decide whether that code is safe to ship are getting scarcer and better paid.
That's the contradiction I opened with, so software is where I'll start.
Software engineering, up close
I come from a software engineering background, and I still use it every day (building custom AI systems for clients), so I'm close enough to this to see the implications firsthand.
On the generation side, the shift is hard to miss. Tools like Claude Code and Cursor let people produce more code, faster, than they could have written themselves five years ago. The version that gets the most attention is "vibe-coding": someone with no coding background describes an app or a website and gets something that runs.
That is one of the main drivers of the "software is dead" narrative, and I can see why. A prompt that produces something that runs looks a lot like the job being done.
There's real value in non-experts using these tools: testing a concept, demoing an idea, showing someone what you mean instead of describing it in words. But something that runs is not the same as something ready to put in front of real users, at scale, with real consequences if it breaks.
If generation were the whole story, we'd be hiring more juniors, handing them AI tools, and shipping production software that way. Exactly the opposite is happening: demand and pay for senior engineers are climbing, not falling, even as these tools get better. The shortage isn't people who can produce code. It's people who can be trusted to decide whether the code that got produced is "production-ready".
Part of why that gap is easy to miss is that the tooling has moved well past a copilot completing a function for you. Agents can now produce a working system end-to-end. But that doesn't remove the decisions underneath; it multiplies them.
An agent doesn't stop to ask, so it can look like there was nothing to decide. But a default still got chosen somewhere: on security, on scalability, on error handling. "It appears to work" is not evidence the default was right, and a non-expert can't tell the difference, because they don't know what to check.
Those defaults are exactly the decisions that stay with a senior person: the right one is different on every project, and nobody finds out what a wrong one costs until it breaks in production. The market is already pricing that in. A Stanford Digital Economy Lab study found junior software developer employment down roughly 20% for the 22-25 age group since its 2022 peak, while employment for older age groups has grown over the same period.
Accounting and law say the same thing
This is not confined to software engineering. Accounting is a good example: it's been declared automatable for years, first by bookkeeping software, now by AI doing more of the routine entry and reconciliation work. What hasn't gone anywhere is sign-off: someone still has to catch a wrong number, not write a better one, and that's precisely the verification task.
I don't work in accounting, but if I asked an AI system to balance my own books, I'm sure the output would look pretty reasonable to me. But looking correct to someone who isn't an accountant is not the same as being correct, and that gap is exactly why a suitably qualified person has to own the sign-off.
It's the same with legal work. AI will draft me a contract that looks convincing to me, but I have no way of knowing whether it would hold up when it's actually tested, and I wouldn't find out until it mattered. Which is really the general rule: AI output is fine to lean on where a mistake costs little, and the more serious the consequences, the more you need someone qualified between the output and the decision. That's as true of developing code as it is of signing accounts or contracts.
To be clear, none of this means AI can't help with these processes. It absolutely can, and building systems that do exactly that is my day job. The point is knowing where the limits sit, and designing the process so that a suitably qualified person still makes the decisions that matter, rather than rubber-stamping whatever comes out.
Does the sign-off go away?
Say models do get better at catching their own mistakes. Does the need for a human to sign off disappear, in software, in accounting, anywhere this pattern shows up?
I don't think so, it just moves. That's the same shape as the Turing Transformation point earlier: cheaper generation raises the value of the judgement that remains. The more output a model produces, the more decisions there are to check, and someone still has to be senior enough to catch the ones that matter.
Adding more people, or more AI, to do that checking doesn't fix it either. A novice can get through just as many checks per hour as an expert; the difference is whether the checks catch anything. The problem was never how many decisions get made, it's whether the person making the call can be trusted to get it right when it counts.
And that gets harder over time, not easier. Even if models start absorbing some of that judgement, they take the easy, well-specified calls first: the ones where the situation is predictable and the price of a mistake is already known. What's left for a human to check is the opposite of that: cases that don't fit the pattern, where nobody's worked out yet what getting it wrong actually costs. That's a moving bar, not a fixed one, so the person doing the checking is likely to remain at least as senior as the person doing it today.
Where do the next seniors come from?
So if the market wants experienced people who can reliably own the verification, but becoming experienced still means doing the routine work first, and AI is increasingly doing that work, then there's a bit of a catch-22. It becomes hard to see where the next generation of seniors comes from.
Figure 2: AI doing the routine work removes the reps that used to build tomorrow's judgement, in any field with this pipeline.
Again, this isn't just isolated to software engineering. Law, accounting, consulting: any field where juniors used to learn by doing the routine work faces the same question. If AI does the junior-level work, what replaces the years of practice that used to turn juniors into seniors?
My honest view is that this is a real problem, and the logic is hard to escape. If everyone hires senior, nobody is training the next senior.
That doesn't mean peer review and mentoring stop working, or that there's no way through this. It means the current version doesn't scale. AI has removed the generation bottleneck, so juniors (and tools) now produce far more output to check. The old review system assumed a more limited amount of work needing a senior to oversee. So the question is how to redesign review and mentoring so they can cope with that higher volume, without just asking seniors to check everything (which would be a full-time job in itself).
Workplace review and mentoring can only go so far, though. The pipeline starts earlier: in how the discipline is taught in the first place. For software engineering specifically, the base of a degree may need to shift away from routine coding practice and toward architecture and theory, because architectural judgement is what will actually matter for a developer's career from now on. I don't have all the answers in this regard, but I think the direction of travel is fairly clear.
What this means for your role
I went looking because I wanted to know whether software engineering was actually dying. The honest answer is no. The job has changed fundamentally, but the human judgement inside it became more valuable, not less.
The wider pattern is the same wherever AI takes over the generating and leaves someone to own the decision. So if you're wondering what AI means for your own role, don't start with how "exposed" the job looks on paper. Ask:
- Who still has to decide whether the output can be trusted once AI has done its part?
- How much would getting that wrong actually cost?
That's what predicts what happens to pay and hiring.
If you are thinking through what this means for roles, hiring, or where judgement still needs to sit in your organisation, get in touch.
References
- PwC 2026 Global AI Jobs Barometer.
- Brynjolfsson, Chandar & Chen, Canaries in the Coal Mine? Six Facts about the Recent Employment Effects of Artificial Intelligence (Stanford Digital Economy Lab).
- Agrawal, Gans & Goldfarb, The Turing Transformation.