Tunnel vision: why agents get stuck, and how to break them out

Here’s one of many reasons developers still need to actively guide coding agents, not just delegate to them: tunnel vision. (I promise I try really hard not to swear at the agent. Mostly.)

Agents are inclined to lock onto a course of action and then completely fail to consider “maybe I made a wrong call originally.” This is a very human failure mode too - helping people notice when their approach is wrong and it’s time to go back to the drawing board has always been one of the core skills of managing developers or dev teams. Agents have the same blind spot, for what’s probably a related reason: the longer an agentic conversation runs, the more the accumulated conversation history weighs on what comes next. Every token of “I’m doing X” makes X more likely to keep being the plan, independent of whether X is still the right plan. You can think of it as a natural consequence of next-token prediction - the model is, in a real sense, arguing with its own transcript.

The operator’s job

Which means the operator has to keep a running sense of what the plan actually is and whether it’s still a good idea. Ideally you catch this before the agent starts implementing, but you can’t always manage that - software development is an exploratory process, and often you genuinely can’t see the implications of a change until you’re partway into making it. Coding agents inherit that same property. They’re magic, but not that magic.

The smells to watch for

A few reliable signals that an agent has tunnelled:

• You keep telling it that something’s broken, in ways that feel like they should have been caught by the original plan.
• It keeps churning in the same area of the codebase, going in circles without visible progress.
• Looking at what it’s doing with an engineering brain, you think: this really shouldn’t be this hard.

That last one is the most useful in practice. If your gut says the task is fundamentally simple and the agent is three iterations deep into something that looks like a fight, that’s the signal to step in - not to debug the specific error it’s stuck on, but to question the approach underneath it.

Breaking it loose

It generally doesn’t take much. Get the agent to explicitly step back and re-assess the original requirements against the current direction - literally ask it to restate the goal and check whether what it’s currently doing still serves that goal. That single reset is usually enough to break the loop, because it forces the model to re-weigh the goal against the accumulated momentum of the conversation, rather than just the next local step.

And no, you don’t have to swear at it to get its attention - but I won’t pretend it doesn’t sometimes feel like it helps.