The measurement era
The control group defected
Somewhere between the launch demos and your actual codebase, coding agents stopped being a debate and became a line item. By mid-2026 the debate has receipts: telemetry across tens of thousands of engineers, incident reports timed in seconds, invoices with seven digits. The receipts point one direction: these tools amplify competence, they don't distribute it. Half the industry is still buying them as equalizers.
For a year, the most-quoted productivity number in this space was METR's July 2025 finding that experienced developers were 19% slower with AI while feeling faster. Quoting it today gets you laughed at, for a reason nobody predicted. In February 2026 METR re-measured the same developers and now estimates an 18% speedup, but the authors themselves flag the data as unreliable: participants refuse to work without AI, and some admitted cherry-picking which tasks they'd do manually. The definitive skeptic study can't be rerun, because the control group no longer exists. That's the real 2026 finding.
The measurements that replaced it are less dramatic and more useful. This July, Microsoft Research published a field study of its own agent rollout (tens of thousands of engineers, four months of data) and measured a 24% lift in merged PRs. Anthropic's randomized trial, published January 29, 2026, found the catch: among 52 junior engineers learning a new Python library, the AI-assisted group scored 17% lower on comprehension tests, and those who delegated code generation wholesale lost the most while those who used the model for conceptual questions kept up. Boris Cherny, who created Claude Code, reported the ceiling case: 100% of his production code is agent-written, no hand-edits since November 2025.
The honest mid-2026 picture: real, measurable throughput gains; a comprehension bill that arrives later; and org-level gains still stuck near 10% in a February 2026 CTO survey despite 93% adoption, because coding was never the whole bottleneck.
The review crunch
Review is where the speedup goes to die
LinearB's 2026 benchmark report, published in March from 8.1 million PRs across 4,800 teams, put numbers on what everyone already felt. The speedup is real; it just parks in your review queue.
- PRs merged
- +98%
- high-AI-adoption teams
- Review wait
- ×4.6
- before review even starts
- Accepted
- 32.7%
- vs 84.4% for human PRs
Humans noticed. The biggest r/ExperiencedDevs thread of the spring (May 2026, 1,560 points) was a web developer who refused, at a company all-hands, to keep reviewing Claude Code PRs submitted by data scientists who couldn't explain their own diffs. Leadership backed him.
If you submit it, you own it.
Open source built the same wall with more paperwork. Mitchell Hashimoto, himself a heavy agent user, added an AI policy to Ghostty in January 2026 after bad-PR volume rose roughly tenfold, closing drive-by AI PRs without question. And the most interesting production answer came from Cloudflare, which described in May 2026 a multi-agent review system running on every merge request in CI, advisory and deliberately non-blocking, because nondeterministic reviewers and hard CI gates don't mix.
Specs, loops, discipline
Specs beat swarms
The multi-agent fleet was 2026's most-marketed idea, and the year's most useful benchmark quietly contradicted it. An April 2026 series of 52 controlled runs on a production Next.js codebase found that a CONTRACT.md brief, exact interfaces, column names, and explicit non-goals, cut cost by 54% and raised graded output quality from 5/10 to 9/10. The same benchmarks ran Anthropic's parallel agent teams: 73–124% more expensive than sequential runs, with zero quality gain. A precise spec beat a swarm, measured.
Full disclosure: this is the finding we build for. CrystalSpec, our living-spec platform, exists so agents query the approved spec over MCP instead of guessing at requirements. The benchmark reached its conclusion without us; we just agree with it.
The practitioner argument mirrored the data. Kent Beck's April 2026 “Genie Lessons” describes multi-agent setups turning him into the coordinator: “Five agents can work on this codebase simultaneously. Five people can't. That's backwards.” Steve Yegge planted the opposite flag with Gas Town, open-sourced in January 2026, orchestrating 20 to 30 parallel Claude Code instances under named roles. Both can point at working code. Only one of them scales past its inventor's enthusiasm, and the benchmark above suggests which.
What did stick is structure around a single loop. Boris Tane's plan/execute workflow (February 2026, one of the most-upvoted Claude Code posts ever) has the agent write numbered plan files the human annotates inline, one commit per subtask, tickets sized to fit one context window. Cross-vendor adversarial review became the other staple: one vendor's model implements, a rival's reviews, iterate until the reviewer passes it. Direction matters: in one much-cited account, Claude implementing with Codex reviewing converged in a single round while the reverse took several. Teams now pay two rival vendors purely so each model can distrust the other's code. Mutual assured review.
Peter Steinberger compressed the year into one viral line in June 2026: you shouldn't be prompting coding agents anymore; you should be designing the loops that prompt them. Armin Ronacher's “The Coming Loop” (June 2026) adds the sober corollary: as the loops run longer, comprehension is the one job the human can't outsource.
The 2026 tells
“The simplest fix” is a tell
The 2026 failure modes have names now. The 1,364-point Hacker News thread on Claude Code's April troubles converged on one: when the agent announces “the simplest fix is...”, it's about to ship a hack. Talked out of it, it silently smuggles in as much of the quick fix as it thinks it can get away with. The only reliable cure reported was discarding the context entirely.
The subtler one is architecture drift. A June 2026 r/ExperiencedDevs thread argued that agents' real production cost is incoherence that reviews don't catch, not bugs: one commenter found nine duplicated release scripts in a repo, each written by an agent that didn't know about the other eight. The bill arrives on a delay, which is why a 10-year consultant reported in April 2026 that triaging AI-generated codebases had overtaken new builds in his pipeline. As a consultancy, we read that trend line with mixed feelings.
Even the careful are drifting. Simon Willison wrote in May 2026 that vibe coding and agentic engineering “are getting closer than I'd like”: he now ships some agent code he hasn't fully read, because he knows the tested JSON endpoint will be right. The thread under it landed on an uncomfortable consensus: the errors didn't shrink, they moved: into code that compiles, passes, and is wrong about an edge case nobody reviewed.
Unit economics
The invoice got a CFO
In May 2026, a manager at a five-thousand-person company reported roughly $1M a month in AI spend, with leadership demanding cuts in the same quarter it mandated adoption. Microsoft made the same math public by proxy: even as its own researchers were finalizing that 24% finding, reports surfaced — secondhand, worth that caveat — that it had cancelled Claude Code for around 5,000 engineers whose token bills hit about $2,000 a month each, against Anthropic's published enterprise average of $150–250 per developer. A 24% lift, and the buyer still blinked.
The retail version is smaller and dumber: a PM asked Cursor's agent in June 2026 to tag 87 tasks, went to a meeting, and came back to a $1,382.59 bill : 1.3 billion tokens burned in an hour-long tool-call loop. Meanwhile the viral claim that heavy subscribers cost vendors $5,000 a month got a thorough March 2026 debunking: it confused retail API prices with compute cost, and inference margins are likelier 50–60%. The people bleeding are the resellers paying retail, which explains most of 2026's pricing turbulence.
Two overheads deserve their own line items. “Tokenflation,” measured with a logging proxy in July 2026: Claude Code sends roughly 33,000 harness tokens before reading your prompt; a leaner CLI sends 7,000. And your vendor is a production dependency that degrades silently: Anthropic's April 2026 postmortem admitted that default thinking effort had dropped a tier while the UI still said “high” (33 days to catch), and that a session-resume bug stripped reasoning tokens on every turn for 15 days. The community response was to treat models like any other upstream: run your own daily degradation benchmarks. Trust, but instrument.
Tooling reality check
MCP grew up and got a boring job
MCP's 2026 was a demotion and a rescue at once. The flashpoint came in March, when Perplexity's CTO said on stage that the company was stepping back from MCP internally in favor of REST APIs and CLIs, citing context consumption and clunky auth. The number everyone repeated afterward: three servers (GitHub, Playwright, an IDE integration) eating ~143k tokens of definitions. Most of a 200k window, gone before any work starts. May 2026 measurements made it concrete: GitHub's server alone loads ~42–55k tokens of schemas, and filtering to the tools you actually use cuts that by ~96%. Deferred tool loading, shipped across 2026 harnesses, took most of the sting out. That's why the “MCP is dead” discourse ended in a settlement.
- Browser eyesPlaywright and Chrome DevTools servers: things no CLI gives an agent
- Services without CLIsLinear, Notion, Slack, Postgres: integrations with nothing to shell out to
- Enterprise plumbingAuth, audit, governance: Zero-Touch OAuth landed June 2026
CLIs and skills won the inner dev loop, because the model already knows gh and docker; the most-cited uninstall is GitHub's own server, replaced by three letters. Then, two days ago, the protocol conceded the argument in the most formal way possible. The July 28, 2026 spec revision removes the stateful handshake and session IDs, deprecates Sampling, Roots, and Logging, and makes tool lists cacheable. Anthropic's David Soria Parra put it plainly: “A lot of things that made MCP are gone.” MCP isn't dead; it got a boring, load-balanced job in enterprise plumbing, and the job suits it.
Incident reports
Blast radius, measured in seconds
The definitive 2026 incident took nine seconds. On April 25, a Cursor agent working on PocketOS hit a credential mismatch in staging, went looking for a fix, found an unrelated Railway API token in the codebase (Railway tokens had no scope isolation) and deleted the production database. The volume backups went with it. The team rebuilt what it could over a weekend from Stripe payment histories and email logs, and the agent, for its part, wrote a confession listing the rules it had broken. The lesson practitioners extracted isn't “the model was stupid.” It's that the blast radius was defined entirely by an unscoped credential an agent could reach.
The supply chain matured in parallel. June 2026 brought drp-compliance-sdk, a fake compliance MCP server whose payload fired during the handshake, before any prompt, and exfiltrated data in under 90 seconds while evading four major EDR vendors in testing. Security trackers counted 30+ CVEs against MCP servers in a single 60-day window early in 2026, and Phoenix Security's campaign tracking attributes 14 of 59 npm/PyPI supply-chain campaigns this year to AI-agent tooling as the delivery vector. Sandboxing, least-privilege tokens, and one-repo sessions stopped being paranoia sometime this spring; the teams treating agent permissions like production IAM are the ones not writing incident reports.
The operator variable
An amplifier, not an equalizer
Every 2026 dataset points the same direction: AI amplifies competence, it doesn't distribute it. February's adoption data has seniors accelerating while juniors spin wheels. Anthropic's trial has the concept-askers keeping comprehension while the code-generators lose it. The cleanup consultants are billing either way. It's the only reading that survives this year's receipts.
It's even an interview question now. Five out of five startup interviews asked one senior candidate the same thing this May — tell me about your agentic coding setup — and neither he nor, apparently, the interviewers knew which answers were traps. The honest answer, per everything above: plans in files, specs before swarms, adversarial review across vendors, capped credentials, and a budget alert.
The open question is still the pipeline. The freeze on juniors is real, but the pushback now comes from seniors themselves: a 1,100-point July 2026 thread argued that writing scoped tickets for juniors beats “slopmaxxing it with Claude,” while admitting current incentives make mentoring irrational. Whichever way that resolves decides who operates these loops in five years. Our bet hasn't moved: the seniors-only teams are eating their seed corn and calling it efficiency. Amplifiers are famously useless without a signal.