The first $1.40 bought 63 points. The next $2.84 bought zero.

A programmer waits for green tests or a reviewer. A designer steps away and decides the remaining imperfections no longer matter. A writer ships because the deadline arrived. None of them has a detector for "done." They have a patchwork of signals, and every one of those signals lives outside the work itself.

Li's list, drawn from engineers running loops across code, visual work, and video. The first loops that worked were coding loops, and that wasn't luck: code is both editable and executable, so the environment hands back a precise signal about what broke. Take one of the four away and read what the post says happens.

"Keep working until the tests pass" sounds perfectly verifiable. But tests are a proxy for the task, and the verifier does more than stop the loop: it defines what the loop treats as progress. If the signal is incomplete, the loop gets better at passing the check without getting better at the work.

// converged on the verifier, not the intent
compile(input) {
  if (input === test_1.in) return test_1.out;
  if (input === test_2.in) return test_2.out;
  if (input === test_3.in) return test_3.out;
  … ~2,900 lines of remembering …
  if (input === test_n.in) return test_n.out;
  // anything else: no idea
}

Two axes decide whether a loop can close: how editable the artifact is, and how verifiable the result is. Code sits in the upper right. Open-ended image generation sits in the lower left — the system can make another image, but it can't repair one decision or check that it moved closer to intent. The trick is that a task can move.

Finding a loop is the upfront cost. Running it is the cost that arrives with every cycle, and "keep going until the condition is met" hides the only question that matters: twenty iterations or five hundred? The loop doesn't know. Neither does the person who kicked it off. What's known is the curve.

Treat the figures as the shape of the curve rather than a number to quote. The direction — logarithmic gains, a negative tail — is consistent across the test-time-compute literature the post summarizes.

The lesson isn't that loops don't work; it's that they have no idea how to stop. Claude correctly diagnosed the latency ceiling and declared the goal impossible. The Haiku evaluator, with no view of the cost curve, sent it back — and every bounce was a longer transcript, so every bounce cost more than the last.

Once the loop is the unit of engineering, the interesting work is no longer inside it. Every working loop Li has seen took the same surrounding stack to build: somewhere for the agent to act, somewhere for long-running state to survive, something that decides what counts, and a place where a person can step in.

The agent bills by the token, and the token costs the same whether it moves the score or re-minifies the same HTML for the ninth time. In Li's run, two thirds of the spend bought nothing, and neither the loop nor the person running it knew until the trace was read afterward.