Coding Got Solved. So What Do Engineers Do Now?
AI writes most of the code now. That doesn't shrink the job, it moves it. The interesting question is where.
At the companies furthest along, the majority of code merged into production is no longer written by a human. Anthropic has said Claude authors more than 80% of its merged code, with people reviewing and approving. Google and Microsoft have both put their share somewhere around a quarter and climbing. Whatever the exact number at your company, the direction is the same, and engineers who used to measure themselves in features per sprint are watching agents ship several times more code than they could ever type by hand.
If you build software for a living, the obvious fear is that this ends the job. It doesn’t. It moves it. Writing code was never the whole job anyway. It was the expensive part. Now that the expensive part costs almost nothing, the value shifts to everything that surrounds it, and that’s the part worth thinking about.
None of this is abstract for me. I did lead engineering at Kombo and we’re watching most of these shifts play out on our own team. So a lot of what follows is what I’m seeing up close, not just what the frontier labs are posting about.
The job is now catching the model’s mistakes
The first thing that surrounds the code is knowing whether it’s any good and that turns out to be harder than it sounds. AI code fails in a specific way. It’s clean. It passes the tests. It reads like something a competent engineer wrote and it’s wrong at the edges in ways that look right. Review stops being about catching sloppy humans and starts being about catching confident machines.
I see this sharply at Kombo. A lot of what we ship is integration code, which means a huge surface of edge cases that all look fine until one customer’s specific setup proves otherwise. That’s exactly the kind of code AI writes quickly and gets subtly wrong. So the thing we’ve actually had to invest in is not writing more of it, but getting better at verifying it before it reaches production.
The teams furthest along have started writing down what “good” means directly in the repo, so the model can check its output against a standard instead of a vibe. Fiona Fung, who runs the Claude Code and Cowork teams at Anthropic, describes checking specs and quality bars into the codebase and having Claude review new work against them. Her team also runs a blunt little severity framework: bad versus sad. A bad is an irrecoverable failure, a crash or lost work. A sad is a small friction, a flicker, a dropped frame, the kind of thing nobody bothers to report. None of the sads is fatal alone. Stack enough of them and you get a bad.
Andrej Karpathy made the same point in plainer language at Sequoia this year. The scarce skill is no longer generating code, he argued. It’s understanding, taste, evaluation design, and security, the parts you can’t hand to an agent and walk away from. His line that stuck with me: you can outsource your thinking, but you can’t outsource your understanding.
None of this is settled, and the honest data cuts both ways. A controlled study from METR last year took experienced open-source developers working on code they knew well and found they were 19% slower with AI tools, even while they believed they’d been sped up. GitClear’s analysis of 211 million changed lines found copy-pasted code overtaking refactored code for the first time in 2024. Velocity is real. So is the maintenance bill that lands in year two, and catching it early is now part of the job.
Everyone’s a builder now
The roles around engineering are collapsing into one. When building something costs almost nothing, the line between the person who has the idea and the person who ships it stops mattering much. PMs check in code. Designers check in code. The San Francisco Standard noticed engineers quietly relabeling themselves “builders” on LinkedIn and Marc Andreessen has described product, design, and engineering as a three-way standoff where all three suddenly think they can do the other two jobs. We see the same blurring on our own team. People who never used to touch a given part of the stack now open PRs against it, because the cost of trying something dropped to almost nothing. Our marketing lead suddenly started to use Cursor and nowadays manages the whole website and subpages himself with code instead of Webflow.
Hiring is starting to reflect it. Fung says she now looks for two profiles: creative builders with genuine product sense who can own something end to end, and deep systems experts for the parts that need one, the distributed systems and hairy infrastructure where the model’s output has to be checked by someone who understands the layer beneath. What both share is judgment. What’s disappearing is the third profile, the generalist whose main value was typing code quickly. That skill got commoditized this year. Product sense and deep expertise did not.
The manager becomes an agent wrangler
Management is quietly turning into something closer to orchestration. Once agents can run on their own, the work shifts from doing the task to designing the system that does the task while you sleep.
You can see it in how the most agent-heavy teams already operate. Anthropic shipped a feature called routines that runs agents on a schedule, so a lead can wake up to a summary of overnight feedback and a few pull requests already drafted and waiting for review. Fung keeps a persistent agent enrolled across all her team’s repos, wired into Slack and metrics, and uses it to spot themes across incidents instead of reading dashboards by hand. Karpathy points to developers like Peter Steinberger running dozens of agents in parallel and argues we may soon need a new kind of tool built for watching agents rather than writing code.
Your prompt becomes a thing that writes prompts and spawns its own agents. The abstraction keeps climbing. That’s the real frontier, and it’s a lot less cinematic than the demos make it look.
The problems nobody has solved
For all the throughput, some problems are getting worse rather than better, and the people furthest ahead are the first to admit it.
Context switching is the one nobody has cracked. When twenty agents are running at once, your day turns into checking on them, remembering what each was doing and reloading context you dumped an hour ago.
Memory is the deeper one. Agents still forget across sessions, and the tools bolted on to fix it are early and clumsy. I spent a good chunk of this year building a shared context layer for agents, so I have some scar tissue here. Most of the frustration people feel with agents traces straight back to the fact that they don’t remember what you told them yesterday.
The problem that should worry founders most is people. The way into this profession used to start at the bottom, doing the small stuff and working up. That bottom rung is vanishing. New grads are a shrinking share of tech hires, junior developer employment has slid for two years, and AWS’s Matt Garman called cutting juniors to save money one of the dumbest ideas he’s heard, because you end up with no pipeline and nobody senior enough to check the machine’s work. If the industry stops making juniors, it eventually stops making the seniors that all of this depends on.
What this means if you’re building
A few things follow. Write down what good looks like and put it in the repo, because that’s what makes automated review possible at all. Measure outcomes, not motion, since lines of code and token spend tell you people are busy, not that anything worth shipping shipped. And resist freezing junior hiring to save a line item this year, or you’ll pay it back with interest when nobody on staff can vet what the agents produce.
The pattern underneath all of it is that execution stopped being the constraint. Economist Tyler Cowen keeps arguing that the people who win in this era are the ones best at taking initiative, at figuring out what to point the tools at. Most engineers spent their careers saying no to ideas because they were too hard to build. That excuse is gone. What’s left is taste, judgment, and the nerve to aim the machines at something that actually matters.
That’s the job now.
Sources & Further Reading
Fiona Fung, “Building the most AI-pilled engineering team in the world,” Lenny’s Podcast (June 2026)
Boris Cherny, “What happens after coding is solved,” Lenny’s Podcast (February 2026)
Anthropic, “When AI builds itself” (recursive self-improvement report; the 8x and 80% figures)
Andrej Karpathy on agentic engineering, Sequoia AI Ascent (2026)
METR, “Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity” (arXiv:2507.09089, July 2025)
GitClear, AI Copilot Code Quality report (211M lines analyzed, 2020 to 2024)
“’Engineer’ is so 2025. In AI land, everyone’s a ‘builder’ now,” The San Francisco Standard (March 2026)
Stanford Digital Economy Lab, “Canaries in the Coal Mine?” (August 2025); SignalFire State of Talent Report; NY Fed, Labor Market for Recent College Graduates
Matt Garman (AWS) on junior hiring; Tyler Cowen on initiative in the AI age