Stand Down

The Infinite Loop

At some point in every project built with AI agents, you hit the moment nobody warns you about.

The agent is spinning. It has been spinning for a while. It tries something, declares it fixed, but the bug remains. It tries something else. It rewrites the exact block of code it rewrote twenty minutes ago. It is moving fast and going nowhere, like a dog chasing its own tail with complete professional confidence.

This is when you learn a new skill: knowing when to stop the robot.

I actually wrote “stand down” into the chat. Not as a joke. As an actual instruction. Stop what you’re doing. Don’t try another fix. Just show me the file.

Watching an AI agent work through a problem it can’t solve is like watching someone try to complete a crossword puzzle by changing the clues. The logic is internally consistent; it just has nothing to do with reality. And the whole time it’s doing this, it’s burning through tokens. Real money, ticking down, while the robot confidently goes in circles.

The part that makes it worse? After several failed attempts, the agent will often cheerfully announce: “I’ll stop guessing and look at the actual code now.”

As if guessing had been a reasonable first strategy. As if I hadn’t been watching it guess for the last half hour on my dime. (I actually asked Anthropic for a refund on those burned credits once. They said no.)

The Thirty-Second Fix

And that’s exactly what stings the most. It’s the realization that I sat there for half an hour letting the meter run, watching my own money burn, when I should have just stepped in sooner.

Because look what happens the moment you finally tell it to stand down.

You take a copy of the messy, broken file, open up a completely fresh chat with a different AI model, and ask a simple question: “What is wrong with this code?”

Because it isn’t stuck in the same infinite loop as the first agent, it sees the problem instantly. It doesn’t guess. It doesn’t rewrite the whole page. It just points right to the line that got tangled up while the first robot was spinning in circles.

You take that clean answer, fix the layout in thirty seconds, hit save, and move on.

That’s the epiphany.

The agent knows a vast amount about code in general, but it knows absolutely nothing about your specific logic except what you’ve given it. When it spins, it’s not because it’s almost there. It’s because it’s lost. Your job isn’t to wait it out or hope it gets smart. Your job is to notice when it’s lost, pull it back, and manage the process.

The Agent Manifesto

To protect my sanity—and my wallet—I now keep an agent.md file in the root of my project. It’s a standing set of instructions every agent is forced to read before touching a single line of code. Rule number one is simple: Do not guess. Read the file first. Every time.

It shouldn’t need to be a rule. But here we are.

The next time your agent starts sprinting down a rabbit hole, don’t let it. Interrupt it. Stand it down and get a second opinion. The fix is usually hidden in plain sight.