What's the smallest, dumbest thing that made you completely lose trust in an AI agent mid task?

I had it create a dashboard for my marketing agency, and it doubled my actual revenue from our QB. I mean I know the numbers but wanted to see all of them together in a dashboard. It did the whole thing flawlessly, until I saw our overall Gross Rev. :) I questioned it then it went and fixed itself. But... still... like a teen, you should always trust but verify!

For me it was an agent that had write access to more than it needed, and it helpfully cleaned up a config it was never asked to touch. The change itself was tiny. The thing that actually broke my trust was that I could not quickly tell everything it had done, or cleanly undo just that one action. The mistake was recoverable. Not being able to see it or reverse it was the part that stayed with me.

And yes, exactly like you, the trust crept back within a week. What actually changed my workflow was not watching the agent more closely, because that does not scale. It was narrowing what each agent could touch in the first place, and making sure every action left a trail I could reverse. Once a mistake is scoped and reversible, a wrong move is annoying instead of scary, and that is the only thing that made the trust stick rather than reset.

Your function rename example is a perfect version of this. The failure was not dramatic, it was silent, and silent is what kills trust. Did narrowing scope or adding review gates ever help you, or are you still mostly relying on catching it by eye?

That grep issue is a perfect example. It's the kind of "sneaky" failure that's way more dangerous than an outright crash. Your agent confidently proceeds because it doesn't know what it doesn't know.

For me, the trust erosion moment came with Claude Code: it started refactoring a function and introduced a subtle type error that only manifested deep in a test suite 3 steps later. The agent had moved on, I'd moved on, and suddenly the codebase was in a broken state. What broke the trust wasn't the error itself—it was that the agent couldn't explain why it had chosen that approach or that it had even considered the downstream impact.

The treacherous part is exactly what you mentioned: trust creeps back in. You rationalize it as "that was an edge case" and start trusting by default again. But I've started explicitly asking agents to trace their reasoning backward—not just "what would you do" but "why would you do that and what could go wrong?"

Neeraj's follow-up question is key: does your awareness change long-term? For me, the answer is "no, but your guardrails should." I'm now more paranoid about search-and-replace operations, multi-file refactors, and anything touching inference paths. The trust never fully recovers—it just gets replaced with better detection.