Finish the Job: Do AI Coding Agents Actually Complete the Work?
· 13 min read

Finish the Job: Do AI Coding Agents Actually Complete the Work?

Surveys and 2026 studies show AI coding agents generate most code but leave the finishing — verification, security, maintenance — to humans. The evidence, and a playbook.

Every 2026 vendor pitch for coding agents leans on the same promise: hand the task to an agent, walk away, come back to finished work. The marketing writes checks that repository history keeps bouncing. Across the surveys, datasets, and randomized studies published over the past year, one consistent picture emerges: AI coding agents are strong at generating code and weak at finishing it. Generation is cheap. Completion — tests that pass, structure that holds, requirements that are actually covered, code that survives review and stays maintained — is the bottleneck. This article walks through the evidence, then closes with a playbook for closing the gap on your own team.

The Autonomy Pitch vs. the Finish Line

Start with what developers actually do, not what demos show. The JetBrains Developer Ecosystem Survey 2026 (published August 26, 2026; 15,000+ professional developers surveyed May–July 2026) (answers don’t sum to 100 because developers’ estimates overlap) found that, on average, ~47% of code is reported as fully written by agents, ~38% written with some AI assistance, and ~27% fully manual. The autonomy headline softens fast: only ~22% of developers report that more than 80% of their code is agent-generated. Senior developers lead adoption, and even among the heaviest users there’s a ceiling — among developers naming Codex their most-used tool, 42% generate more than 80% of their code with agents, versus 32% for Claude Code. That’s the top of the curve, not the norm.

Sonar’s State of Code Developer Survey (published January 8, 2026; 1,100+ professional developers) tells the complementary story: AI accounts for 42% of committed code, expected to reach 65% by 2027, and 72% of developers who tried AI use it daily. But 96% of developers do not fully trust AI-generated code.

Read those two surveys together and the real workflow appears: agents generate most of the text, humans blend, check, and finish. That isn’t autonomy. That’s pair programming with a very fast typist who never quite closes the ticket.

Generation Is Cheap; Completion Is the Bottleneck

The cost of unfinished work shows up in repository history. “Debt Behind the AI Boom” (arXiv 2603.28592, v2 April 26, 2026) built a dataset of 302.6k verified AI-authored commits across 6,299 GitHub repos, covering five assistants: GitHub Copilot, Claude, Cursor, Gemini, and Devin. Those commits introduced 484,366 distinct issues, 89.3% of them code smells. More than 15% of commits from every assistant introduced at least one issue. And 22.7% of tracked AI-introduced issues were still surviving at each repo’s latest revision — unresolved debt sitting in the codebase months later.

There is one genuinely encouraging finding: AI commits fix more code smells than they introduce. Agents are useful at cleanup. But the same dataset shows those commits introduce roughly 1.5x more security issues than they fix. The net is positive for style, negative for safety-critical concerns.

The second paper measures what happens after merge. “Do These Violent Delights Have Violent Ends?” (arXiv 2607.09902; 182 repos, commits merged May 1, 2025–May 31, 2026) found that agentic contributions receive a ~46% higher corrective-maintenance rate and a ~45% higher bug-fix rate than human lines. The generation arrives in seconds. The finishing arrives afterward, as cleanup, as fixes, as work someone has to schedule.

What “Done” Actually Means in 2026 AI Coding

“Done” cannot mean “the tests passed.” The “Needle in the Repo” benchmark (arXiv 2603.27745) evaluated 23 coding configurations and found that, on average, only 36.2% of maintainability-preserving edit probes were solved — the best configuration managed 57.1%. Pass rates collapse as scope grows: 53.5% on micro cases fall to 20.6% on multi-step cases. Worse, 64 of 483 outcomes (13.3%) passed all functional tests yet failed the structural/maintainability oracle. The code ran. It still wasn’t finished.

Stack the other two costs of “done” on top. From the Debt Behind the AI Boom dataset: agents introduce ~1.5x more security issues than they fix, so a security review is part of finishing, not an optional extra. And a Harness survey, as cited by Sonar, found 67% of developers report spending more time debugging AI-generated code. A task is done when tests pass and the structure holds and the security review is clean and the debugging budget is accounted for. Agents reliably deliver the first item. The rest is the job.

The Verification Gap: Merged Without a Check

Here is the most uncomfortable number in this entire article. Sonar’s survey found that only 48% of developers always verify AI-generated code before committing — while 96% say they don’t fully trust it. Nearly half the industry is shipping code it explicitly distrusts, unverified.

The consequences are measurable. The agentic-maintenance study found that each 10 percentage-point increase in a project’s no-review merge rate associates with roughly a 6% increase in agentic maintenance burden. Skipping review doesn’t save time; it moves time to later, with interest.

The systemic numbers agree. Google’s DORA 2025 report, as cited by Sonar, found that a 90% increase in AI adoption is associated with an estimated ~9% climb in bug rates, a 91% increase in code review time, and a 154% increase in pull request size. Review is where the finishing happens — and it is the step whose volume grows fastest as AI adoption grows.

Maintenance: The Human Tax on Agent Output

If agents were finishing the job, they would also maintain what they wrote. They don’t. A study built on the AIDev dataset (arXiv 2605.06464; 100 popular repos, ~3,200 changes) found that human developers perform ~83% of maintenance on AI-generated files; agents perform only ~17%. The most common modification made to AI-generated files is feature extension — finishing requirements coverage — while human-authored files typically receive bug fixes. In other words: agents start the work, humans complete it.

That human tax compounds. The same 182-repo study found agentic lines receive both a ~46% higher corrective-maintenance rate and a ~45% higher bug-fix rate — two views of the same corrective load, which is concentrated in bug fixes. And per the Harness survey, as cited by Sonar, 67% of developers already spend more time debugging AI-generated code. When you evaluate an agent’s price per task, the honest unit cost includes the reality that most downstream upkeep on agent-written files lands on your team.

The Productivity Paradox: Slower but Confident

The best-controlled study in this space is also the most humbling. A METR randomized controlled trial (published July 2025) found that experienced open-source developers were 19% slower with AI tools on their own repositories. Their forecast before the study was that AI would make them roughly 24% faster — and even after living through the slowdown, they still believed it had sped them up by about 20%. The gap between felt productivity and measured productivity exceeds 35 percentage points even after the evidence is in front of them.

This matters because the volume of AI code is going up regardless. Sonar’s survey expects AI to account for 65% of committed code by 2027. Confidence is driving adoption faster than measurement is validating it. If your team’s sense of speed comes from how it feels to generate code, you are measuring the cheap half of the job and ignoring the expensive half.

What “Autonomy” Marketing Doesn’t Say: From ACUs to Quotas

Vendor pricing tells you what vendors actually believe about autonomy. We fetched Devin’s pricing page on 2026-10-08. The plans are: Free at $0/month, Pro at $20/month, Team at $80/month, and Max at $200/month. The page’s own FAQ describes quota-based plans, and the string “ACU” appears zero times on the page. The latest model banner is SWE-2. Whatever the terminology, the structure is clear: you are buying metered work capacity, not finished outcomes. Pricing pages in this market meter effort, because completion is exactly what can’t be guaranteed.

Where Completion Fails: Evidence from 2026

The table below consolidates the failure modes, the measured evidence, and the signal to watch for in your own workflow.

Failure modeWhat the evidence showsPractical signal
Completion deficitOnly ~22% of developers in the JetBrains 2026 survey report >80% agent-generated code; NITR finds a 36.2% average probe pass rateTreat “mostly autonomous” as a top-decile case, not your baseline plan
Verification gapSonar: 96% don’t fully trust AI code, only 48% always verify; arXiv 2607.09902: +10pp no-review merges ≈ +6% maintenance burdenNo review, no merge — automate the gate so it can’t be skipped
Maintenance loadAIDev study: humans do ~83% of maintenance on AI files; arXiv 2607.09902: ~46% higher corrective-maintenance rateBudget maintenance hours for agent-written code as a known cost
Debugging burdenHarness survey, as cited by Sonar: 67% spend more time debugging AI-generated codeTrack debugging time separately from generation time
Productivity illusionMETR RCT: 19% slower while still believing AI sped them up ~20%Measure cycle time and rework, not vibes
Structural failureNITR: 13.3% (64/483) pass all functional tests but fail the maintainability oracleAdd structure/lint/architecture checks to your definition of done
Quality regressionDORA 2025, as cited by Sonar: +154% PR size, +91% review time, ~9% bug climb; GitClear research, as cited by Sonar: 8-fold rise in 5+ duplicated-line blocks; arXiv 2603.28592: ~1.5x security issuesWatch duplication, PR size, and security findings per commit
Autonomy mismatchDevin pricing (fetched 2026-10-08): quota-based plans, zero “ACU” mentionsRead pricing pages for what’s actually metered — effort, not outcomes

Practical Playbook: How to Finish the Job in 2026

1. Redefine “done” beyond functional tests. NITR showed that 13.3% of agent outputs pass every functional test and still fail the maintainability oracle, and that only 36.2% of maintainability-preserving edits succeed on average. Add structural checks — linting, architecture rules, duplication limits — to your definition of done, and run them in CI where agents and humans face the same gate.

2. Make verification mandatory and unfakeable. Sonar found only 48% of developers always verify before committing, despite 96% distrusting the code. Require human review on every agent-authored change. The evidence backs this: each 10-point rise in no-review merges adds roughly 6% to agentic maintenance burden.

3. Run a security pass specific to agent code. The 302.6k-commit dataset shows AI commits introduce ~1.5x more security issues than they fix, and more than 15% of commits from every assistant introduce at least one issue. Point security scanning at agent-authored diffs before merge, not after release.

4. Budget the maintenance tax explicitly. Plan for humans to perform the bulk of upkeep — ~83% of maintenance on AI-generated files is human work — and for the elevated correction rates (~46% higher corrective maintenance). If you don’t allocate those hours, they’ll be allocated for you, mid-sprint.

5. Track debugging time as a first-class metric. 67% of developers already spend more time debugging AI-generated code. Log it. If debugging plus review plus rework exceeds the time saved on generation, you have data instead of a hunch.

6. Scale your verification before your adoption. AI code is expected to reach 65% of committed code by 2027. Verification capacity that works at 42% will break at 65%. Build the review and structural-gate capacity now, while the volume is still manageable.

FAQ

Are AI coding agents actually completing full tasks autonomously? Mostly no. The JetBrains 2026 survey puts fully agent-written code at ~47% on average, with only ~22% of developers above the 80% mark — and even that code still requires review, security passes, and maintenance. The realistic 2026 workflow is heavy AI generation with substantial human finishing.

Why do developers feel faster with AI if measured studies show slowdowns? Generation feels fast, and perception anchors on generation. The METR trial found developers were 19% slower on their own repos — yet even afterward they still believed AI had made them about 20% faster. The hidden work — debugging, reviewing, correcting — happens after the burst of output that shapes intuition.

What is the biggest hidden cost of AI-generated code? Maintenance. Humans perform ~83% of maintenance on AI-generated files, agentic lines carry a ~46% higher corrective-maintenance rate, and 67% of developers report more debugging time. The generation discount gets paid back, with interest, in upkeep.

Does agentic tooling replace human maintenance? No. Agents perform only ~17% of maintenance on their own output, and the most common edit to AI-generated files is feature extension — humans finishing what the agent left open (arXiv 2605.06464). Current tools generate far better than they sustain.

Is passing functional tests enough to consider a task finished? No. In the NITR benchmark, 13.3% of outcomes passed all functional tests yet failed the structural/maintainability oracle, and multi-step task pass rates fall to 20.6%. Add structural checks and a security review — agents introduce ~1.5x more security issues than they fix.

What does Devin’s pricing page tell us about autonomy? It shows vendors price effort, not outcomes. Devin’s pricing page, fetched on 2026-10-08, lists quota-based plans (Free $0, Pro $20, Team $80, Max $200 per month) with zero mentions of “ACU” and a SWE-2 model banner. If end-to-end completion were reliable, per-completed-task pricing would be viable. The market hasn’t produced it for coding agents.

The Bottom Line

The evidence is consistent and it is not anti-AI — it is anti-hype. AI coding agents have earned their place: ~47% of code is now agent-written on average, agents fix more code smells than they create, and daily use is standard. But no dataset reviewed here shows end-to-end autonomy in production. Completion remains the bottleneck: 22.7% of AI-introduced issues persist in repos, humans do 83% of the upkeep, and only 48% of developers always verify code they admit they don’t trust.

The verdict for ToolBrain readers: treat agents as fast, tireless drafters. Buy the generation — it’s cheap. Then budget, staff, and enforce the finishing: review, structural checks, security passes, and maintenance hours. The teams that win with AI in 2026 won’t be the ones that generate the most code. They’ll be the ones that actually finish the job.

How This Guide Was Built

This article is based on desk research of dated, publicly available sources: the JetBrains Developer Ecosystem Survey 2026, the Sonar State of Code survey and its press release, three arXiv studies (2603.28592, 2607.09902, 2605.06464), the NITR benchmark, the METR randomized controlled trial, and DORA, GitClear, and Harness statistics as cited by Sonar.

The only first-person work in this guide is the ToolBrain pipeline fact — our own 12-lane arena-generated draft required a judge pass, a citation QA pass, and format gates before publish — and the live fetch of Devin’s pricing page on 2026-10-08. No hands-on testing of any AI coding tool was performed for this article. All figures trace to the sources linked inline; DORA, GitClear, and Harness statistics are cited via Sonar because that is where we verified them. Nothing here is a vendor recommendation; it is a read of the evidence with a playbook attached.

  • ToolBrain — tool reviews, LLM comparisons, and AI workflow guides
  • CodeIntel Log — code quality, debugging, and software engineering benchmarks

Cross-links automatically generated from None.

Back to all posts