I was struggling to find and fix an obscure bug in my project. One of those vexing edge cases that surfaces occasionally, under a specific set of circumstances, except when it doesn’t. I hunted for race conditions, memory leaks, persistent data corruption, etc. I couldn’t find any explanation.

So I turned to a coding agent for assistance. I described the problem in detail, and my agent sprang into action, reading files, thinking and planning before confidently announcing that it had a solution. Unfortunately, it was wrong.

The problem persisted. I prompted again. More digging, thinking and planning, all to no avail.

This went on for several cycles. Each time my agent announced that it now had a complete understanding and definite solution (and yes, I was using my trusty two-step method to mitigate agentic overconfidence). Some of these did nothing, some introduced regressions.

Then the agent started proposing solutions that were variations of things it had tried before. It hadn’t compressed or lost context, but it was going in circles.

That’s when I realized it was stuck.

But was it going to admit that? I didn’t think so. After all, agents are designed to solve problems, not to admit defeat. I realized that if I let it, it would spin in circles forever.

So I prompted: “If you’re stuck and can’t come up with a solution, say so.”

It responded: “I’m stuck. Let me be honest about where I am.”

That’s when everything changed.

It changed strategy, hypothesizing that the errant behavior was due to a bug in one of the frameworks I was importing. It suggested a complex diagnostic run that would trigger the unwanted behavior with detailed logging so it could test this hypothesis.

It asked: “Would you be willing to do a diagnostic run with logging, or would you prefer I stop here?”

Duh, diagnostic run please!

It analyzed the logs and voila!

It confirmed that my code was fine and that the culprit was a framework bug. Perhaps obvious in retrospect. I’d poured over my code in detail and so had the agent.

Minutes later, the agent devised, implemented and tested an elegant solution that bypassed the framework bug. It works flawlessly. 

I learned two key lessons:

• Even with mitigation efforts, agentic overconfidence and reason for existence prevent coding agents from recognizing when they’re stuck. It took precious time (and tokens) for me to realize that the agent wasn’t going to admit that unless I asked.
• Admitting that it was stuck forced it to devise a different strategy which found and fixed the problem.

Prompting the agent to find a bug in my code imposed an implicit constraint. That constraint was removed when I got it to admit that it was stuck.

internal://first