What is prompt fatigue? (when fixing one bug takes fourteen prompts)

What it actually is

Prompt fatigue is what happens when you’re deep in a back-and-forth with your AI agent trying to fix one bug, and instead of closing in on the fix, you’re circling it. Prompt three fixes the symptom you described. Prompt seven half-fixes what prompt three broke. By prompt fourteen you’re re-explaining the original bug from scratch, because nobody, including you, remembers what “fixed” was even supposed to look like anymore.

It’s the coding equivalent of steadying a wobbly table by shimming one leg, then shimming the shim because it still wobbles, then shimming that. Each fix is locally reasonable. The table is somehow worse than when you started.

Why your AI just did this

Two things stack on top of each other. First, context accumulation: every prompt and every reply stays in the conversation, including the wrong turns. When you ask for another fix, the agent is reading the whole exchange, its own earlier mistakes included, and can anchor on a diagnosis it already committed to instead of re-examining the code with fresh eyes. Second, patch-on-patch: an agent trying to make an error message go away will often reach for the smallest edit that plausibly clears the symptom, not the edit that addresses the actual cause, especially once you’ve already told it the bigger fix didn’t work. Each attempt narrows toward “stop the error” rather than “understand the bug,” and those two targets drift further apart the longer the loop runs.

When you’ll run into it

• You’ve sent six or more prompts about the same error, and the message keeps changing shape without actually going away.
• The agent says some version of “That should fix it” for the third time in a row, and it doesn’t.
• You can’t remember which fix undid which earlier fix, and scrolling back through the last ten messages doesn’t make it clearer.
• You started with a one-line bug report and the conversation now includes three unrelated refactors the agent proposed along the way.
• You keep burning prompts (and credits, if you’re on a metered plan) on the same feature, and each round is getting more expensive to fix, not cheaper.

What to check

• Count how many prompts you’ve spent purely on this one bug. Past four or five with no forward motion, that’s the fatigue signal, not a reason to send prompt six
• Whether the last few fixes actually touched the file or function connected to the error, or just silenced the message (a try/catch, a null check, a stray “TODO”)
• Whether you can still state the original bug in one sentence. If you can’t, the scope has drifted and needs resetting, not another patch
• Start a fresh session. In Claude Code, /clear wipes the conversation but keeps your CLAUDE.md and project files, so the agent still knows your project without the failed attempts attached
• Shrink the ask to one file or one function instead of “fix the bug,” so the agent can’t wander into the rest of the codebase trying to “fix” things that were never broken

Say it like a dev

Instead of: “it’s still not working, try again” Say: “let’s stop, here’s the one thing that’s still broken, in one sentence”

Instead of: “just keep trying different things” Say: “revert the last two changes and let’s start this fix in a fresh session”

Instead of: “why do you keep breaking other stuff” Say: “scope this to just the login function, don’t touch the rest of the file”