The bottleneck moved
If you'd asked a year ago what limited how much AI could help with a coding task, most people would've said "the model isn't good enough yet." That's an increasingly outdated answer. Models across the major coding agents now handle non-trivial, multi-file tasks with a level of reliability that would've sounded implausible in 2024. The bottleneck moved somewhere else: it's no longer what agents can do, it's how effectively a human can direct and review several of them working at once.
That's a real reframing of the job, not a marginal productivity boost. Writing the actual code — the thing that used to eat most of a developer's day — is becoming the part of the workflow that takes the least deliberate thought, provided you've described the task well.
The autonomy axis, not a single winner
The current landscape has split cleanly along one axis: where does the agent live, and how much of the loop happens without you watching. Terminal-native agents give you a programmable teammate you drive with prompts, running locally with direct filesystem and shell access — good for deep, interactive sessions where you're pairing closely with the agent. Editor-native agents sit inside your IDE with an autonomy slider, building and testing features while you review inline. Cloud-based agents go further still, running unattended for hours in an isolated sandbox, opening a pull request when they're done, with no expectation you were watching in real time.
None of these postures is strictly better. They optimize for different kinds of work, and increasingly, teams run more than one — a terminal agent for the hard, ambiguous problem you want to pair through carefully, a cloud agent queued up in parallel for the batch of small maintenance tasks that used to eat 30-40% of a morning.
What "supervising agents" actually looks like day to day
In practice, this looks less like typing and more like triage. A developer describes a handful of tasks clearly enough that an agent can run with them unsupervised, queues them up, and moves on to something that needs a human's judgment. Later, they come back to review a batch of diffs — checking not "does this look like plausible code" but "did this actually solve the right problem, and did it introduce anything I need to catch before it merges."
That review step is where the real skill lives now, and it's a different skill than writing code quickly. It's closer to code review at scale, applied to work you didn't watch get written, from an agent that will confidently present a wrong solution with exactly the same tone as a right one.
What doesn't change
Architectural decisions, understanding why a feature matters to the business, and knowing which trade-offs are acceptable for your specific product are still squarely human work — no agent, however autonomous, has the context to make those calls for you. The job isn't disappearing. It's shifting weight: less time producing code, more time deciding what should be produced and verifying that what came back actually did the job.
