From suggestion to delegation
For a couple of years, "AI coding assistant" mostly meant a smarter autocomplete — it finished your line, maybe your function, and you stayed in the driver's seat the whole time. That framing quietly broke down. The tools people are reaching for now aren't finishing sentences; they're being handed a task description and left alone to plan, write, run tests, iterate on failures, and open a pull request.
That's not a small difference in UX. It's a different relationship with the work. You stop reviewing keystrokes and start reviewing outcomes.
What actually changed
A few things converged. Models got meaningfully better at multi-step reasoning over a codebase — not just predicting the next token, but holding a plan across dozens of tool calls without losing the thread. Harnesses matured around that capability: coding agents gained the ability to run shell commands, execute test suites, read error output, and revise their own approach without a human re-prompting them at every step.
The result is a class of tools that increasingly separates into two postures. Some agents live inside your editor, watching you work and jumping in when asked. Others run asynchronously in a sandboxed environment — a cloud VM, a container, a worktree — and you check in later the way you'd check on a coworker's progress rather than a tool's output.
Why this matters more than it sounds
The practical shift isn't "AI writes more code now." It's that the unit of work being delegated got bigger. Instead of "autocomplete this line," it's "fix the auth bug in the onboarding flow" or "migrate this component to the new design system." The agent decides how to get there.
That changes what a developer's day actually looks like. Instead of typing continuously, more of the job becomes: writing a clear task description, reviewing a diff, deciding whether the approach was right, and deciding what to hand off next. It's closer to managing than typing, for a growing share of the work.
The catch nobody skips mentioning
None of this removes the need for judgment. Agents are still confidently wrong in ways that are easy to miss if you're not paying close attention to the diff — a test that passes for the wrong reason, an edge case quietly dropped, an assumption about your architecture that doesn't hold. The developers getting real value out of this shift aren't the ones handing off the most tasks; they're the ones who got disciplined about reviewing what comes back.
The tools left the autocomplete box. The responsibility for what ships didn't go anywhere.