Originally published on Medium.
A one-year follow-up to “When AI Codes the Future, What Becomes of Human Ingenuity?”
Last August, I wrote that human ingenuity would move from execution to orchestration. It did — faster than I expected. What I didn’t see coming was the bill — and it’s denominated in trust.
A year ago, I wrote that the future innovator would be less a builder and more a director, curator, and strategist. Back then, “AI coding” mostly meant a copilot suggesting your next line. You typed, it autocompleted, you hit tab.
That world is gone. And its replacement came with a price tag nobody put in the forecast.
First, the Argument Held Up
Today, you don’t ask AI to finish a line — you assign it work. An agent reads your repository, plans a multi-step implementation, edits files across the codebase, runs the tests, interprets the failures, and iterates. Sometimes an entire feature is done before a human reviews the first diff.
The numbers tell the story. In the Pragmatic Engineer’s 2026 survey, 55% of engineers regularly use AI agents — 63% at the staff level. Sonar’s survey of 1,100+ professional developers found AI now accounts for roughly 40% of committed code, and developers expect that to hit 65% by 2027. Most engineers don’t use one tool; 70% juggle two to four, treating agents the way a manager treats a team.
We are not pair programming anymore. We are managing teams of agents. The orchestration thesis wasn’t just directionally right — multi-agent architectures, where an orchestrator coordinates specialized agents and synthesizes their output, became the literal product architecture.
So the argument landed. Here’s what it revealed.
Then the Bill Arrived
The bill isn’t money. It’s trust — and the human hours it takes to earn it back, one review at a time.
The paradox that defines 2026: adoption went up, and trust went down. Usage climbed past 80% of developers while the share who trust AI output to be accurate dropped to under a third.
This is not a contradiction. It’s economics. Do the math with me.
Careful human code review runs at roughly 200–400 lines per hour — a rate set by human cognition, documented for decades, and it hasn’t budged. Generation, meanwhile, went from maybe 100 solid lines per developer-day to thousands per hour. The cost of producing code collapsed ~100x. The speed of reading it improved 0x.
Now stack on the quality tax. Studies show AI-generated code carries security flaws at nearly 3x the rate of human-written code, and two-thirds of developers say their biggest frustration is output that’s “almost right, but not quite.” Almost right is the most expensive kind of wrong — it survives a skim and fails in production. So each AI-generated line deserves more scrutiny per line, not less. You’re reviewing code nobody on your team wrote, defending reasoning you never watched unfold.
Run it on a single feature: an agent produces 2,000 lines in 20 minutes. Rigorous review at 300 lines per hour is nearly 7 hours of human attention. Twenty minutes of machine time, a full day of human time. Review used to be a rounding error — maybe 15% of the effort on a feature. Now it’s most of it. The ratio didn’t shrink. It inverted.
And this isn’t hypothetical — it’s already showing up in time sheets. A Q1 2026 survey of nearly 3,000 developers found they now spend 11.4 hours per week reviewing AI-generated code versus 9.8 hours writing new code. For the first time, the average developer reads more code than they write. Sonar’s industry report gave the phenomenon a name — the “verification bottleneck” — finding that 96% of developers don’t fully trust AI-generated code, and 38% say reviewing it takes more effort than reviewing a human colleague’s work.
This is why trust fell while adoption soared. It’s not that developers became cynics. It’s that when generation becomes free, verification becomes the product. The bottleneck didn’t disappear; it moved. And in any system, the bottleneck is where the value concentrates.
The scarce resource is no longer the ability to generate. It’s the ability to verify.
The New Human Frontier, Repriced
Last year I listed four human superpowers: framing problems, taste and judgment, ethical curation, and interdisciplinary integration. All four held up. But if verification is the new bottleneck, the market should be repricing human skills around it — and that’s exactly what I see happening. Three skills are commanding the premium:
1. Context engineering. The cheapest code review is the one you never have to do. The best orchestrators don’t write better prompts — they build better environments: persistent project rules, reusable domain knowledge, clear task boundaries, agent-readable documentation. Every hour spent engineering context is hours of downstream verification you don’t pay. The craft moved from writing code to designing the conditions under which agents write code that passes review the first time.
2. Delegation intuition. Engineers are developing a new instinct: knowing what to hand off and what to keep. The pattern is consistent — delegate what’s cheap to verify, hold onto what’s conceptually hard or design-dependent. Notice the criterion: it’s not “what can AI do?” It’s “what can I check?” Delegation intuition is verification economics, internalized. Nobody taught it in school, and the people who have it are visibly outperforming the people who don’t.
3. Accountability without authorship. When an agent ships the code, the human still owns the outcome. Review is no longer optional politeness — it’s the job itself. The most valuable engineers in 2026 review agent output the way a senior engineer reviews a junior’s pull request: inspect the diffs, run the tests, probe the edge cases, question the security posture. The typing was never the hard part. The judgment always was.
Three skills, one common denominator: each one drives down the cost of verification. That’s not a coincidence. That’s the market finding the bottleneck.
Cheap Generation Democratized Building. Verification Still Gatekeeps Shipping.
One more theme from last year’s piece came true in a way I underestimated: the wall between “people who code” and “people who don’t” is dissolving. Security teams analyze unfamiliar code with agents. Data teams build their own frontends. Program managers — my own tribe — build internal tools that would have required an engineering team two years ago.
I know because I did it. I’m a TPM (Technical Program Manager), and this year I built and shipped an internal agentic platform that generates structured program reviews from scattered organizational context. Cheap generation is what let me build it. But what made it ship-worthy wasn’t the generation — it was domain judgment: knowing what a good program review looks like, what leaders actually need, what’s signal and what’s noise. I could verify the output because I’d spent a decade learning what “right” looks like in my domain.
That’s the honest version of democratization: AI collapsed the cost of building. It did not collapse the cost of knowing whether what you built is any good. Anyone can generate now. Verification is still earned.
The Future of Recognition, Revisited
Last year I used chess as the analogy: engines play better than any grandmaster, yet we still celebrate humans for creativity and courage. I’d sharpen that now.
In 2026, the analogy isn’t the grandmaster. It’s the coach. The engine can evaluate twenty moves deep, but the coach decides which engine lines to trust, which to discard, and which a human can actually execute under pressure. The engine generates. The coach verifies. The engine is table stakes. The coach is the differentiator.
Recognition is following the same path in software. Nobody asks “who typed this?” anymore. The questions that matter now: Who scoped it? Who caught what the agent missed? Who decided it was safe to ship?
The Question Nobody’s Pricing In
The forecasts are already written. Developers expect AI’s share of committed code to hit 65% by 2027. Gartner projects nine in ten enterprise engineers will use AI assistants by 2028. And the next wave is visible in this year’s industry reports: agents reviewing agents — AI checking AI-generated code for defects, security flaws, and consistency at a scale no human team can match.
I believe those forecasts. Which is exactly why they raise the question nobody’s pricing in:
When verification itself gets delegated, what’s left?
Here’s my answer, and it’s where I’ll pick up next year’s follow-up: the human role compresses one more level. From writing the code, to checking the work, to defining what “good” means in the first place. The standards. The constraints. The taste. Agents can review agents — but something still has to tell the reviewer what to reject, and that something is a human with a point of view.
Which means the last durable human skill isn’t coding, and it isn’t even orchestration.
It’s knowing what you actually want — and having the judgment to recognize it when you see it.
AI made code cheap. It made judgment priceless.