Your Coding Tool Stopped Autocompleting and Started Doing the Work

A year ago, an AI coding tool was fancy autocomplete. You typed, it finished the line. Useful, but you were still doing the work — it was just guessing your next few keystrokes.

That’s not what these tools do anymore. Over the last few weeks, the agentic coding tools most professional developers reach for — the ones that run in your terminal instead of a chat box — quietly changed what they do by default. They now kick off tasks that run in the background while you do something else. They draft their own pull requests for you to review. And the models underneath them hold roughly a million tokens of context at once — enough to read an entire codebase before touching a single file.

Put those three shifts together and you get something that isn’t autocomplete at all. It’s a teammate you hand a task to.

What actually changed

The individual updates sound like release-notes trivia. Taken together they’re a redefinition of the job:

• Background work. You describe a task, the agent goes off and does it while you keep working on something else, and it comes back with a result. You’re no longer babysitting every step.
• The agent opens the pull request. Instead of you assembling the change and writing it up, the tool drafts the whole thing — the code and the explanation — and your job becomes reviewing and approving it.
• A million tokens of context. The default models can now hold an enormous amount of a project in their head at once. That’s the difference between an assistant that edits one file and one that understands how a change ripples across the whole system.

And this isn’t one company’s bet. The same pattern — hand an agent a task, let it run in the background, review what it produces — is showing up across the industry, including in the big cloud platforms racing to offer managed agent runtimes of their own. When every major vendor ships the same shape at the same time, that’s the shape of the work now, not a feature war.

Why this matters for your career

Here’s the uncomfortable part and the opportunity, in the same sentence: the thing these tools got great at is exactly the thing an entry-level developer used to get paid to do. Take a well-defined ticket, write the code, open the PR. That loop is increasingly the machine’s.

What the machine still can’t do is decide what to build, break a vague goal into tasks worth handing off, judge whether the agent’s output is actually right, and take responsibility when it ships. That work — the direction, the judgment, the review — is going up in value at exactly the rate the typing is going down.

We’ve been calling this the shift from coder to orchestrator, and the last month made it concrete. The developer who thrives now isn’t the one who memorized the most syntax. It’s the one who can take a fuzzy business problem, decompose it into work an agent can run, and then catch the bug the agent’s confident-sounding pull request slipped in. That’s a different skill set — and almost nobody was formally taught it, because until recently it didn’t exist as a job.

The skill isn’t “prompting”

It’s tempting to reduce all of this to “learn to prompt.” It’s more than that. Directing an AI teammate well is a real discipline: scoping a task so it’s neither too big to trust nor too small to bother, giving it the context it needs and nothing that’ll mislead it, reviewing its output like a senior engineer reviews a junior’s, and knowing which decisions you must never delegate. Those are judgment skills, and judgment is built by doing the work with feedback — not by watching a video about it.

The forward-looking read is simple. The floor is rising: routine implementation is becoming a commodity anyone with a good agent can produce. The ceiling is rising too: a single person who can direct a team of agents can now ship what used to take a whole team. The gap between those two is where careers are made over the next few years — and it’s a gap you close by practicing the direction, not the typing.