Anshad Ameenza.
Engineering··Updated: Nov 5, 2026

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.)

A timeline of one engineer’s day shipping a retry change with an AI editorSix stacked rows. 09:00 specify, she writes the change as a one page spec. 09:40 decompose, she splits it into four small tasks, each with a check. 10:00 editor, the agent drafts about 600 lines across nine files. 11:00 review, she finds the retry window is off by one second. 14:00 verify, she writes the tests that pin the behavior. 16:30 own, she merges and her name is on the pager. Footer: about forty minutes of the day were her own keystrokes. Five rows are amber for human judgment, one is cobalt for machine work.One retry change, one day09:00 · Specifywrites the change as a one-page spec09:40 · Decomposesplits it into four small tasks, each with a check10:00 · Editorthe agent drafts about 600 lines across nine files11:00 · Reviewfinds the retry window is off by one second14:00 · Verifywrites the tests that pin the behavior down16:30 · Ownmerges, and her name is on the pager tonightabout 40 minutes of the day were her own keystrokes
In an illustrative day, the editor did the typing and every hour that mattered went to judgment.

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.

Horizontal bars from the 2025 Stack Overflow Developer Survey on AI tool use and trustSix bars. 84 percent use or plan to use AI tools. 46 percent distrust the accuracy of AI output. 33 percent trust it. 3 percent highly trust it. 66 percent name almost right but not quite as a top frustration. 45 percent say debugging AI code takes longer. Adoption is cobalt, trust and frustration bars are amber.Stack Overflow Developer Survey · 2025use or plan to use AI tools · 84%distrust the accuracy of the output · 46%trust the accuracy of the output · 33%highly trust it · 3%top frustration, almost right but not quite · 66%debugging AI code takes longer · 45%bar length is the share of respondents
Almost everyone uses the tools. One in three trusts what they produce, and the top complaint is code that is almost right.

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.

Bars comparing expected, perceived, and measured speed change in the METR 2025 studyA vertical zero line in the middle. Expected before the study, 24 percent faster, a bar extending right. Believed afterwards, 20 percent faster, a bar extending right. Measured, tasks took 19 percent longer, a bar extending left. 16 experienced open source developers, 246 real tasks, early 2025 AI tools.METR · 2025 · 16 developers · 246 tasksexpected before · 24% fasterbelieved after · 20% fastermeasured · 19% slowerslowerfasterreal issues in mature repos the developers knew well
The developers predicted a speedup, measured a slowdown, and still reported a speedup afterwards.

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.

Two stacked pipelines showing the bottleneck moving from writing to reviewTop panel, before the editor: four stages, write, review, verify, ship. Write is highlighted as the narrow stage, hours of typing per change. Bottom panel, after the editor: the same four stages. Write is now cobalt and fast, minutes. Review is highlighted amber as the narrow stage where the queue forms, because reading code you did not write takes longer than reading your own.Before the editorwritereviewverifyshiphours of typingthe queue formed at the keyboardAfter the editorwritereviewverifyshipminutesqueue forms herereading code you did not write is slowerthan reading code you did
Making writing cheap does not make shipping cheap. It moves the queue to the stage that still needs a person.

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.

One vague task compared with four decomposed tasks that each carry a checkTop panel: one task, make checkout faster, produces a single diff of about 1,200 lines that nobody can review properly. Bottom panel: four tasks, each with its own check. Cache the tax lookup, checked by identical totals on 500 saved carts. Batch the database reads, checked by the query count per request dropping. Lazy load product images, checked by measured page load. Remove dead retry code, checked by an unchanged error rate.One vague ask“make checkout faster”one diff · about 1,200 lines · nobody reads it allFour tasks, four checkscache the tax lookupcheck: identical totals on 500 saved cartsbatch the database readscheck: query count per request dropslazy-load product imagescheck: page load measured before and afterremove dead retry codecheck: error rate unchanged for a weekthe check is written before the code exists
A vague task produces an unreviewable diff. The same work, cut into pieces that each carry a check, can be reviewed in minutes.

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.

Four stacked cards listing the limits of the evidence behind this modelCard one: the METR developers had only a few dozen hours with Cursor, and the authors say learning effects may take hundreds. Card two: the tools were early 2025 models, and newer ones may change the result. Card three: the repos were large, mature, and well known to the developers, and greenfield work may differ. Card four: the survey measures sentiment, not output.Where the evidence is thinLittle practicea few dozen hours with the tool; METR sayslearning effects may need hundredsEarly-2025 modelsthe authors say future models may notshow the same slowdownExperts on home groundmature repos they knew deeply; new codeor unfamiliar code may behave differentlySurveys measure feelingtrust and frustration are self-reported,not a measure of shipped defectsthe direction of the shift is clearer than its size
The slowdown is a measurement of one setting, not a law of AI-assisted engineering.

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.

AICoding AgentsSoftware EngineeringCode ReviewDeveloper Productivity
Share:
Anshad Ameenza
About the Author

Anshad Ameenza

Lifelong Learner, Engineer, Technology Leader & Innovation Architect

20+ years of experience in technology leadership, innovation, and digital transformation. Building and scaling technology ventures.

Only if you find it useful

No pitch here. If these pieces are worth your time, you can get new ones in your inbox. If not, skip it with a clear conscience, nothing is being sold. Rare emails, no spam, leave whenever you like.

Continue Reading

Related Articles