VS Code 1.124 shipped a week ago and changed a default that now affects every Copilot user who auto-updates. Autopilot is on — agents write files, execute terminal commands, auto-respond to tool prompts — without pausing to ask permission. The three-iteration cap in Advanced mode is the only thing that stops an autonomous run before human review.
Most developers who received this update didn't read the release notes. VS Code auto-updates silently. For them, their coding environment changed and they may not know it.
The feature is fine. The default is the problem.
What Changed, Specifically
Before 1.124, Copilot in agent mode still stopped at consequential actions. Writing to a file, running a shell command, invoking a tool — each prompted for approval. That friction annoyed experienced users who'd already calibrated which actions were safe to batch. For everyone else, it was also a learning mechanism: approving each step means reading each step, and reading each step builds a working model of what the agent is doing inside a session.
Autopilot removes that pause. Advanced Autopilot adds a secondary model that reads the session transcript and caps loops at three iterations before surfacing results for review. Three is low enough to prevent runaway token spend, high enough for an agent to write three rounds of wrong code before a developer sees the diff.
Who Gets Better at Autonomous Agent Use, and How
Anthropic published analysis of Claude Code sessions earlier this month tracking behavioral changes across hundreds of agent interactions. New users (around 10 sessions in) auto-approve roughly 20% of turns and interrupt about 5% of them. Experienced users (750+ sessions) auto-approve over 40% of turns and interrupt about 9%.
Both numbers increase with experience. That's the finding worth sitting with.
Auto-approve and interrupt rate are different skills that develop on different timelines. Auto-approve is pattern recognition for "this action is safe to batch" — built from accumulated evidence about which agent behaviors reliably succeed without hand-holding. Interrupt rate is something else: recognition that a session is drifting, catching a trajectory going wrong mid-run on signals the agent hasn't flagged, before it completes and you're looking at a diff rather than a live sequence.
The low interrupt rate in beginners isn't careful monitoring. It's not yet having developed the feel for what a failing trajectory looks like before the session ends. The low auto-approve isn't caution — it's not yet knowing which actions are safe to hand off. Neither resolves by being handed a more autonomous mode. Both resolve through accumulated sessions and deliberate attention to what happens inside them.
Autopilot-by-default gives users the approval model that experienced users built 750 sessions' worth of evidence to earn. It doesn't give them the mental map that makes that model coherent.
The Trust Data Going the Other Way
Stack Overflow's 2026 developer survey found 46% of developers actively distrust the accuracy of AI tools. Three percent "highly trust" the output. Trust in AI accuracy has fallen from 40% to 29% over the past year. Sixty-six percent say they spend more time fixing "almost-right" AI code now than a year ago.
Experienced developers are the most skeptical: lowest "highly trust" rate at 2.6%, highest "highly distrust" rate at 20%. The developers most accountable for code quality are the least confident in AI output.
The VS Code default runs against this. The developers most likely to use Autopilot well — who have built up session history and healthy skepticism about AI accuracy — are the ones who already turned it on themselves months ago. The developers now running it by default are statistically more trusting of AI output than the evidence supports, and less practiced at the interrupt patterns that catch autonomous runs going sideways.
Defaults apply a setting designed for a subset to a population that includes many people it doesn't fit.
What Autonomous Sessions Hide
When an agent runs three iterations without pausing for approval, the session produces code you didn't consciously approve at each decision point. The git diff shows what changed. It doesn't show which file the agent considered and rejected, what approach it tried first, or what constraint it was navigating when it made each edit.
When you approve each step, you're building a running mental model of what the agent is doing. You can answer "why is this implemented this way" because you watched it happen. When Autopilot runs to completion and surfaces a result, you're inheriting an outcome. Your relationship to that code is closer to reviewing someone else's PR than writing a function.
For disposable scripts or isolated, well-tested code, the distinction doesn't matter much. For anything you'll debug next month or explain to a teammate, it does.
There's a tracking gap too. If you're building intuition about which types of AI-assisted sessions produce code that holds versus code that comes back for revision within two weeks, session-level observability matters. System-level tracking — OS process activity, editor windows, commit timing — still captures when the session happened and how long it ran, even when the agent ran silently inside it. It's the minimum you'd want: knowing a session occurred, even when you weren't making moment-to-moment decisions inside it. We built xeve's coding session tracking specifically for this boundary — time in the codebase from open to commit, regardless of whether you were writing or reviewing AI output. Autopilot makes that perimeter harder to reason about, not easier.
The Default Pattern
This is the second time this spring that Microsoft shipped a default-on Copilot change that altered developer workflows without an explicit prompt. The April change added "Co-authored-by: Copilot" trailers to every Copilot-assisted commit automatically. Developer reaction led Microsoft to reverse it to opt-in within days.
The Autopilot default didn't get reversed. The feature is probably net-positive for developers who were going to turn it on anyway and now don't have to. For the larger group who auto-updated without reading release notes — which is most people — the default experience changed underneath them.
Defaults matter in proportion to how many users never change them. The Anthropic data says it takes hundreds of sessions to develop the operational pattern that makes autonomous agent mode useful rather than opaque. Stack Overflow says trust in AI accuracy is falling as experience with these tools accumulates. Those two things don't point toward "enable by default and let users opt out."
The developers for whom Autopilot-by-default makes sense are the ones who already know when to turn it off.