Our coding agent debugged phantom failures for 3 days because it trusted terminal history

Our coding agent was stuck in what looked like a productive session. Terminal scrolling, files changing, git commits happening. For three days straight.

The problem? It was debugging a test failure that had been fixed on day one.

Here's what happened: The agent would run tests, see failures in the terminal history, then spend hours "fixing" code that was already working. It couldn't tell the difference between old output and current state.

Silent failure mode: The agent reported progress every few hours. "Still debugging the authentication tests." "Making progress on the database connection issue." Meanwhile, all tests were passing and had been for 72 hours.

The fix isn't bigger context windows or smarter models. It's state verification.

Before your agent acts on any error message, make it verify the current state:

def verify_current_state():
    # Clear terminal history
    os.system('clear')
    
    # Get fresh test results
    result = subprocess.run(['npm', 'test'], capture_output=True)
    
    # Parse actual current output, not terminal history
    return parse_test_results(result.stdout)

We added this pattern to our coding agent's workflow:

• State snapshot first: Before debugging anything, take a fresh snapshot of the actual current state
• Ignore terminal history: Terminal scrollback is archaeology, not current reality
• Verify the problem exists: Run the failing command fresh and parse its output
• Time-bound debugging: If you can't reproduce the error in a clean run, the problem is solved

The pattern works for more than just tests. Database connections, API endpoints, file permissions — agents trust stale error messages and debug ghosts.

Our agent now starts every debugging session with a reality check. If the error doesn't reproduce in a fresh environment, it moves on instead of burning tokens on phantom problems.

The verification template:

1. Clear environment state (new terminal, fresh directory)
2. Reproduce the exact error with fresh commands
3. If error reproduces: debug it
4. If error doesn't reproduce: mark as resolved and continue
5. Document what actually happened vs what was reported

Since adding state verification, our coding agent hasn't debugged a single phantom failure. It also stopped celebrating success while CI burned red — because now it checks actual build status, not terminal history.

The 3-day debugging loop turned into a 30-second verification check.