
Writing code was never the scarce part of the job. The data is starting to show it.
TL;DR
AI coding agents sharply increased code output, but finished software barely moved. Review became the bottleneck.
The most exposed work is "turn a clear spec into code," and the squeeze is hitting junior roles first.
The skills gaining value are specifying, verifying, and owning what ships.
When firms adopted AI coding agents, something odd happened. A Harvard working paper that analyzed engineering data from hundreds of companies found this:
Code output | Finished work | Time to review a pull request |
|---|---|---|
Up roughly a third | No statistically significant rise | Up about half |
After firms adopted AI coding agents. Source: Chen and Stratton, Harvard working paper (not yet peer-reviewed). Exact figures vary slightly between versions.
More code. Not more software.
That one result says a lot about whether AI will take your job, because it points at what the job actually is. If typing code were the bottleneck, agents would have flooded the world with finished features. Instead the bottleneck moved: to deciding what to build, reviewing what got built, and owning it once it's running.
Code got cheap. Everything around it didn't.
Think about where your week goes. Writing code is one slice, next to reading code, reviewing other people's code, debugging, planning, deploys, and working out what the ticket actually means.
Say coding is a third of your time and an agent makes it 30% faster. The whole cycle gets about 8% shorter. That's a real gain, and nowhere near the 2x or 3x that demos suggest.
Then the new costs show up. Reviewers now face more and larger diffs, written by something that doesn't understand why the system is the way it is. In the Harvard data, the extra output piled up in the review queue. As one senior engineer interviewed for the paper put it, there is only one bottleneck at a time: speed up coding and the bottleneck moves somewhere else.
Here is the delivery pipeline, and where things stand now:
flowchart LR
A["Specify<br/>what to build"] --> B["Write<br/>code"]
B --> C["Review"]
C --> D["Deploy"]
D --> E["Own it in<br/>production"]
classDef cheap fill:#d1fae5,stroke:#059669,color:#064e3b
classDef bottleneck fill:#fee2e2,stroke:#dc2626,color:#7f1d1d
classDef scarce fill:#dbeafe,stroke:#2563eb,color:#1e3a8a
class B cheap
class C bottleneck
class A,E scarceGreen: now cheap. Red: the new bottleneck. Blue: where the scarce skills are.
Takeaway: The scarce skills are the ones around the code: specifying what should exist, verifying that it's correct and safe, and owning it when it breaks at 3 a.m.
Your job title matters more than you'd think
US government data splits "programmers" from "software developers," and the two have diverged sharply.
Occupation (US, BLS data) | Employment change, 2023 to 2025 |
|---|---|
Programmers | -27.5% |
Software developers (more design-oriented) | -0.3% |
A staffing executive quoted by IEEE Spectrum said nobody predicted that programmers, rather than call-center workers, would take the biggest hit. He attributed it to how solitary and structured the work is.
Occupation categories are blunt instruments, and other forces are at work too. But the direction fits a clear pattern: the more your work looks like "take a well-defined spec and produce code," the more exposed it is. The more it looks like deciding what the spec should be, the less.
The squeeze is at the bottom
The evidence
Stanford researchers found that employment of software developers aged 22 to 25 fell nearly 20% from its late-2022 peak by mid-2025, while older developers' employment kept growing.
A study of US job vacancies, published by the IZA institute, found junior software postings dropping 14-15% relative to senior ones after ChatGPT's release, a gap that did not appear in mechanical engineering.
The pushback
One analysis reported by the Irish Times argues the apparent AI effect shrinks once you account for whether a role is remote, since coding jobs are disproportionately remote.
IBM has said it is tripling entry-level hiring, betting that juniors with AI can take on work that once needed more experience.
Why juniors, if it is AI? Junior work is mostly well-scoped tickets: clear spec, small blast radius, easy to check against tests. That is exactly what agents do best. What makes a mid-level or senior engineer valuable is mostly tacit: why the billing module has that strange special case, which service falls over under load, how this team really ships. None of that is in the repo.
The pipeline problem. Every senior engineer was once a junior who learned that tacit layer by doing the small stuff. Companies that stop hiring juniors are borrowing from a future in which nobody is ready to become senior.
Takeaway: The first rung is where "codified" work lives, so it's where AI bites first.
Feeling fast is not the same as being fast
In a 2025 randomized trial by the research group METR, experienced open-source developers worked in their own mature codebases, with and without AI tools.
Effect of AI on task time | |
|---|---|
What developers predicted beforehand | 24% faster |
What they believed afterward | about 20% faster |
What was measured | 19% slower |
That study used early-2025 tools, and it was small: 16 developers. METR's 2026 follow-up was too noisy to settle the question, and METR says developers are probably faster now than a year earlier.
The lasting lesson is about perception. Your gut feeling about your own speed, and about your own job security, is not data. Measure the first, and read the evidence on the second.
A developer's week, sorted
A rough rule of thumb for any task that lands on your plate:
flowchart TD
S["A task lands on your plate"] --> Q1{"Is the spec clear?"}
Q1 -- No --> H1["Stays human:<br/>work out what to build"]
Q1 -- Yes --> Q2{"Can tests or a quick<br/>review verify the result?"}
Q2 -- No --> H2["Changing shape:<br/>AI drafts, you verify closely"]
Q2 -- Yes --> Q3{"Is a mistake cheap<br/>to fix?"}
Q3 -- No --> H2
Q3 -- Yes --> A1["Shrinking fast:<br/>mostly automated"]
classDef human fill:#dbeafe,stroke:#2563eb,color:#1e3a8a
classDef shift fill:#fef3c7,stroke:#d97706,color:#78350f
classDef auto fill:#d1fae5,stroke:#059669,color:#064e3b
class H1 human
class H2 shift
class A1 autoAnd here is how common developer tasks land:
Task | Trajectory | Why |
|---|---|---|
Boilerplate and CRUD scaffolding | Shrinking fast | Clear patterns, easy to check |
Tests for existing code | Shrinking fast | The behavior is already defined |
Mechanical migrations and refactors | Shrinking fast | Rule-based, verifiable by tests |
One-off scripts, regexes, queries | Shrinking fast | Small and self-contained |
Bug fixes with a clear repro | Changing shape | AI proposes, you verify the fix |
Feature work in a familiar codebase | Changing shape | You direct and review more than you type |
Code review | Changing shape | More volume, and now the bottleneck |
Clarifying vague or conflicting requirements | Staying hard | Needs context and conversations |
Hard-to-reverse design decisions (data models, service boundaries, security) | Staying hard | Costly mistakes, and someone must be accountable |
Debugging production with partial signals | Staying hard | Messy and context-heavy |
Negotiating scope | Staying hard | Runs on trust and relationships |
Carrying the pager | Staying hard | Accountability can't be delegated to a model |
What to do about it
Get very good at review. Practice reading a diff like a hostile reviewer. The bugs that matter in AI-generated code tend to be quiet ones: a missing authorization check, a race condition, an error swallowed silently, a query that works on ten rows and dies on ten million.
Write the spec, and write the tests first. The better you can state what "correct" means, in prose and in tests, the more you can safely delegate. Tests are how you make a fast, unreliable contributor trustworthy.
Own something end to end. A service, a migration, an on-call rotation. Ownership is where tacit knowledge accumulates, and it's the hardest thing to hand to a tool.
Learn the domain, not just the stack. An engineer who understands payments, logistics, or clinical workflows can judge what's right. An engineer who only knows the framework competes directly with an agent.
Run an experiment on yourself. For two weeks, track how long comparable tasks take with and without AI. Use your own numbers instead of anyone's headline.
If you lead a team, protect review capacity, keep pull requests small, and keep hiring juniors. Pair them with seniors so they get the tacit knowledge, not just the tickets.
Treat it as early evidence
The Harvard paper is a working paper, not yet peer-reviewed, and different versions report somewhat different numbers while agreeing on the conclusion. The tools are changing faster than studies can keep up.
And "no detectable drop in engineering headcount yet" is not a promise. A later revision of the paper adds a forward-looking model in which firms eventually get more output with fewer engineers. That's a simulation, not an observation, but it's a fair reminder that the story isn't finished.
The bottom line
AI is unlikely to take "software engineer." It is far more likely to take the narrow version of the job: the person who converts tickets into code and does little else. That version is shrinking now, and it is shrinking first at the entry level.
The version that is growing in value decides what should exist, checks that it's right, and stays accountable for it. If you can't yet say which version your current role is, that is the most useful thing to figure out this week.
Sources
Stanford Digital Economy Lab: young-worker employment update, August 2026
IZA Discussion Paper 18723: ChatGPT and entry-level software hiring (Lightcast vacancy data)
Irish Times: What if remote working, not AI, is to blame for weak junior hiring?
METR: Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity
Comments(0)
Join the discussion by logging into your account.
No comments yet. Be the first to comment!