The Engineer After the Editor: What the Job Becomes When AI Writes the Code
When the AI editor writes most of the code, the engineer's job moves to specifying, decomposing, reviewing, and owning correctness. Judgment is the bottleneck.
Early November is crowded for developer tools. OpenAI’s DevDay Exchange runs in London on November 3 and in Mexico City on November 11, and Cursor takes its Compile conference to New York on November 5. Developer events show generation on stage because generation looks good on stage: a prompt goes in and a working feature comes out a few seconds later.
Here is the question those demos can’t answer. If the editor writes most of the code, what is the engineer still paid for? And does handing over the typing actually make a good engineer faster?
We don’t know yet. The best controlled evidence we have points the uncomfortable way, and the developers in that study got it wrong about themselves. So before getting to a model, it helps to look at one person’s day.
One engineer, one change, and forty minutes of typing
A senior backend engineer on a payments team has to change how failed card charges get retried. It is an ordinary ticket. Here is how her day goes when the editor does the writing. (She is a composite, built from the shape of the work, not a real person.)
The one-second bug is the whole story. The agent wrote a retry window that looked right, compiled, and passed the tests it wrote for itself. A customer’s card would have been charged twice in a narrow race. She caught it because she knew what the payment processor does at the boundary, and the editor did not.
Her day had five jobs in it. The editor did one of them.
The model: four jobs remain when the typing leaves
Here is the model the rest of this piece uses, in one sentence: an engineer’s work is a loop of specify, decompose, review, and own, and the editor removed the typing from the middle of that loop without touching the other four.
That sounds like good news, and partly it is. But the four that remain are the slow, expensive, judgment-heavy parts. Typing was never the hard part of her job. It was the part that hid how much of the job was thinking. Three findings from the last year of data say what happens when the cover comes off.
Finding 1: developers adopted the editor faster than they came to trust it
The largest annual developer survey measured both adoption and trust in 2025. The two numbers went in opposite directions.
The 2025 Stack Overflow Developer Survey found 84 percent of developers using or planning to use AI tools, up from 76 percent the year before. Distrust of the output’s accuracy rose to 46 percent, from 31 percent. Only 3 percent said they highly trust it.
The frustration line is the one to sit with. “Almost right, but not quite” is exactly the retry bug from the payments ticket. Code that is obviously wrong is cheap; you throw it away. Code that is almost right costs a reader who knows enough to find the gap. Developers are telling us, in their own words, that the work moved to that reader.
Finding 2: feeling faster and being faster came apart
If the editor is doing more of the work, the obvious expectation is a speedup. The best randomized test of that expectation in real codebases found the opposite, and found something stranger alongside it.
METR’s July 2025 randomized trial gave 16 experienced open-source developers 246 real issues from repositories they already maintained, and randomly allowed or banned AI tools per issue (mostly Cursor Pro with Claude 3.5 and 3.7 Sonnet). With AI allowed, issues took 19 percent longer. Before starting, the developers forecast a 24 percent speedup. After finishing, they estimated they had been 20 percent faster.
The gap between those bars is the important part. Experienced engineers could not feel where their own time went. Prompting, waiting, and reading generated code felt lighter than writing it, even when it took longer. If self-reports are that unreliable, a team that judges its tools by how fast the work feels is measuring the wrong thing.
Finding 3: the narrow point in the pipe moved to review
Put the first two findings together and you get a mechanism. This part is reasoning, not a measured result, but every piece of it is visible in the payments ticket.
When writing took hours, review kept pace without anyone planning for it. Now a change arrives in minutes, at a size no human would have typed in one sitting, written in a style the reviewer did not choose. The queue moves to the first stage that still needs a person who understands the system.
That is why the payments engineer spent her best hours on a 600-line diff. It is also a fair explanation for METR’s slowdown: the time saved typing went into prompting, waiting, and reading, and reading is where experienced people are slowest because they are careful.
The lever that is left: decomposition you can check
If review is the narrow point, the highest-leverage skill is shaping work so review stays cheap. That happens before the editor writes anything.
The check is the specification in a form a machine can’t argue with. “Make checkout faster” gives the editor nothing to aim at and the reviewer nothing to verify against, so review becomes reading line by line and hoping. Four tasks with four checks turn review into confirming that each claim holds. That takes minutes.
This is where seniority now shows up. A junior engineer and a senior one can type at the same speed, and with an editor they generate at the same speed too. The difference is that the senior one knows which four pieces the work splits into, and which check would have caught the one-second retry bug.
What this gets wrong
The model leans hard on one study and one survey. Both have limits that cut against parts of the argument.
METR’s own write-up warns against reading the result as universal. Its developers had a few dozen hours with Cursor, and the authors note that skill with these tools may take hundreds of hours to build. The models were early-2025 models. The repositories were large and mature, and the developers knew them better than any agent could, which is the setting where an assistant has the least to add. On a greenfield prototype, or in a codebase the engineer has never seen, the numbers could flip.
The survey has the opposite problem. It tells us how developers feel, which Finding 2 shows is a poor guide to what is happening.
So the model is confident about direction and humble about size. The typing has left the loop; that much is visible on every team using these tools. Whether the four jobs that remain make engineers net faster, slower, or about the same depends on how well they do those four jobs, and nobody has measured that cleanly yet.
What to do before the next demo
When the next stage demo shows an editor building a feature in thirty seconds, ask what happens at minute thirty-one. Who reads it? Against what check? Whose name goes on the pager?
Those are the jobs that stayed. They were always the expensive part of engineering; the typing just used to hide them. The engineers who do well after the editor will be the ones who get good at them on purpose: writing the spec before the prompt, cutting work into pieces that each carry a check, reading generated code as skeptically as a stranger’s pull request, and owning the result anyway.
Start with the next ticket. Write the check first.
