tempo / notes / the retry spiral

pattern

The retry spiral, and how to notice you're in one

Three retries on the same test in nine minutes. From the inside it feels like being nearly there. From the outside it is one of the most legible patterns in software work — and it has a reliable exit that nobody takes, because taking it feels like losing.

You know the shape. One test is failing. You have a theory. The theory is wrong, but only slightly wrong, so the fix is nearly right, so the next theory is a small variation on the last one. Twenty minutes in, you are no longer debugging — you are permuting. The variations are getting smaller and the confidence is not going down.

This has always existed. What changed is the cost of an attempt. When each retry meant writing the code yourself, the friction was its own circuit breaker: somewhere around attempt three you got bored enough to go and think. An agent removes that. A retry now costs one sentence and forty seconds of waiting, so you can take twelve of them in the time it used to take to take three — and nothing in the loop ever gets boring enough to break it.

Debugging versus spiralling

The difference is not effort or duration. It is whether information is accumulating.

DebuggingSpiralling
Each attemptTests a different hypothesisVaries the last attempt
Your model of the bugGetting more specificUnchanged since attempt one
What you could explainMore than an hour agoExactly what you could before
Instructions to the agentStill whole sentencesno. revert. try again
Felt distance from doneRoughly accurate"Nearly there" — for forty minutes

That last row is the load-bearing one. A spiral is characterised by a stable sense of imminent success that does not update on evidence. It is the same mechanism that keeps people at a slot machine, and it is not a character flaw — it is what a partial-reward schedule does to anybody.

The signature, from outside

What makes this pattern useful is that it is measurable without reading a single line of your code. The signature is structural:

  • Repetition on one target. Multiple attempts against the same file or the same test in a short window. One target, many tries — not many targets.
  • Error rate above your own normal. Not an absolute threshold. Your baseline, exceeded.
  • Prompt collapse. Instructions shortening from two sentences to a fragment. This is the strongest single tell, and the one people recognise instantly when it is shown back to them.
  • Urgency markers. Words like "just", "quickly", "still", and the swearing. The vocabulary of a session narrows under load.
  • Time of day, and time since a break. Spirals at 11pm after six unbroken hours are a different event from spirals at 10am.

Why the shape is enough. None of those signals require the content of your prompts, your file contents, or your command strings. Word counts, error flags and a salted hash of a target answer the question completely. Tempo measures exactly this and stores nothing else.

Why you cannot see it from inside

Detecting a spiral requires comparing your current state to a baseline — and the faculty that does comparison is the one being consumed by the spiral. Worse, the spiral supplies a specific reason not to stop: you are nearly there. Stopping while nearly there is irrational, so you do not stop, so you remain nearly there.

The sunk cost makes it tighter. At attempt nine, stopping means conceding the previous eight bought you nothing, which is a more painful thought at attempt nine than it was at attempt two. The longer it runs, the more expensive the exit feels — which is precisely backwards from the truth.

The exits that actually work

  1. Count, out loud. "This is attempt six on the same test." Saying the number is often enough on its own, because the number does not feel like the experience. The experience feels like attempt two.
  2. Demand a different hypothesis, explicitly. Not "try again" — ask for three different explanations for the failure before any more code is written. A spiral cannot survive being asked to enumerate alternatives.
  3. Read the error again, from the top. Actually read it. In a spiral you have been pattern-matching the first line for twenty minutes. The answer is startlingly often in the part you stopped reading.
  4. Take the forty seconds. Not fifteen minutes — you will refuse fifteen minutes. One long exhale, feet on the floor, eyes off the screen. It is short enough that refusing it costs more than doing it, and it is enough to break the narrowing. What that actually involves.
  5. Write down the state, then stop for the day. Three lines: what fails, what you ruled out, what you would try next. The spiral's real cost is not the hour; it is that the hour ends with nothing written down and the state has to be rebuilt tomorrow anyway.

The counterintuitive part: the best moment to break a spiral is not when it becomes unbearable. It is at a seam — the moment something lands, a test passes, the agent finishes. Those moments feel like the worst time to stop, which is exactly why they are cheap to stop at.

Being told, by something that is not also tired

This is the case for measurement rather than willpower. Tempo watches for exactly this signature — retries clustering on one target, error rate above your own baseline, prompts collapsing, urgency, the hours behind you — and when the pattern is strong enough it offers one 40-second reset in a seam, citing the signal that earned it: "3 retries on the same test in 9 minutes."

The citation is the part that works. "You seem stressed" is dismissable. A count is not.

Get the count you can't argue with

Free through the beta. It offers at most twice a day, only at a seam, and a single decline silences it.

curl -fsSL https://trytempo.net/install.sh | bash

Piping to bash deserves a look first — read the script, or see the other install options.

no accountno network callsnever interrupts