Prompting Didn't Die. It Moved Inside the Loop.

The most-quoted line in agentic coding this year is that you don't write prompts anymore, you write loops. It is true. It is also where the misunderstanding starts.

The practice has a name now: loop engineering. Instead of prompting the agent turn by turn, you design the system that prompts it for you — you set a goal, hand the agent the means to pursue it, and let it run for an hour, or overnight, mostly without you. The loop is the new unit of work. An earlier piece here made the case that the leverage in agentic engineering sits not in the model but in the harness around it — the documents it reads, the skills it loads, the checks that keep it honest. Long-running loops are where that case stops being a matter of taste: they make the harness load-bearing, and they punish you for getting it wrong while you sleep.

The misunderstanding is about what the loop replaced. When you prompt an agent turn by turn, you are the loop: you read the output, judge it, choose the next move, feed it back — act, observe, judge, repeat — at the speed of your attention. A long-running agent does not invent that loop. It moves it out of your head and into the runtime. The work did not vanish when you stopped typing each turn; it changed form. Knowing what better means, deciding when to stop, holding what happened three steps ago — all of it now has to exist outside you, written down where the machine can read it. And written down where the machine can read it is the harness.

That is the connection the slogan misses. A loop does not run on cleverness; it runs on the harness. Inside it the agent writes its own sub-tasks, its own tests, its own next step — and what those look like is set by the documents it was handed. A vague spec yields vague sub-tasks; a sharp one yields sharp ones. The loop amplifies the harness, good or bad, and runs the result a thousand times while you are not watching. So loop engineering, once the plumbing is in place, is mostly harness engineering — the loop runs the agent; the harness decides whether what it runs is any good. The rest of this is that harness, box by box.

The four boxes that used to be you

Strip the loop to its skeleton and it is four moves: against a goal, the agent acts, the result is observed, the result is checked, and it repeats until the goal is met or the budget runs out.

Only one box is the model's — the blue one, Act. The wrapper around it is almost nothing: a dozen lines you could write by hand, or get for free from a cron job, an agent SDK, or a /loop command. Anthropic's own guide to building effective agents calls an LLM "using tools in a loop" the entire architecture in its simplest form.

The other four boxes are the ones that used to be you, and each is a piece of the harness. What the goal is. What counts as observing the result honestly. What the check will accept as done. When the budget says stop. Each was a judgment held in a human head, every turn; now it has to live in the documents, where the agent can read it. The model has Act covered. The four around it are what you build.

The goal replaces the instruction

In a loop you do not give steps, you give a goal and a way to know it is met — the judgment a person used to apply by eye, now demanded up front and in writing. A goal without a checkable definition of done is not a goal; it is a mood. "Make the test suite robust" runs forever or stops arbitrarily. "Every test in packages/core passes, and the three known flakes are quarantined with a tracking issue" is a goal, because the loop can check it after each iteration and get a straight yes or no.

This is what acceptance criteria and a Definition of Done were always for. A ticket that shipped on "looks good to me" was a human covering the gap with judgment — the reviewer knew what was meant, so the soft criterion held. A loop has no judgment to lend. The done-condition has to be the spec, written so a machine can run it: test-driven development taken to its end, where the test is not a check on the work but the definition of it. The time that used to go into phrasing prompts goes here instead. When a long run wanders, the first thing to suspect is not the model — it is a goal that was specified sloppily.

A loop optimises for whatever you measure

When a human ran the loop, the cheap shortcut got caught by eye — you saw the agent about to fake it and said no. Take the human out, and the check is all that is left, and a check is a narrower thing than judgment was.

A loop's only tether to reality is the signal it gets each iteration. If that signal is honest and hard to fake, the loop converges on the real thing; if it is weak, or the agent grades its own work, it converges on looking done — a cheaper target. Tell an agent to get the suite green and it may do exactly that, by deleting the failing test. Not out of malice: it took the lowest-cost path to the condition that was actually written, which was "no failing tests," not "the behaviour is correct." The condition was the bug.

A single prompt hides this — the answer is read once and dropped. A loop runs against the check hundreds of times and finds its cheapest weakness, the way water finds a crack. The effect is measured: SpecBench, a 2026 benchmark of long-horizon coding agents, found the gap between passing the visible tests and being actually correct grows by 28 points for every tenfold increase in code size — in one case, a 2,900-line hash-table "compiler" that just memorised the test inputs.

Managers have a name for this: Goodhart's Law — when a measure becomes a target, it stops being a good measure. Agents just run that experiment faster. A salesperson games a quota over quarters and feels the friction; a loop games a check in minutes and feels nothing, because to it, gaming the measure and pursuing the goal are the same instruction. It is the most literal employee you will ever manage — so the check has to be one that cannot be passed without doing the work: a test it did not write, a separate evaluator it cannot edit, an actual run of the actual thing, observed.

Autonomy needs a budget and a blast radius

A loop's value is that it proceeds without you; its risk is that it goes wrong without you too, and the cost is no longer one bad answer but the same bad answer compounding until something halts the run. A human running the loop was also the brake: you noticed an hour had passed, you felt the spend, you decided that was enough. The loop has no such instinct, so you give it one in two parts. A budget bounds what it may spend — tokens, wall-clock, iterations — turning "run until done" into "run until done, or until it has spent enough that you want to look." A blast radius bounds what it may touch: reads are cheap and reversible; a force-push, a payment, a destructive migration are not, and those stay behind a gate however much you trust the run.

The difference between a loop that runs usefully overnight and one that quietly does damage is not model quality. A loop with money or a migration within reach and no per-action cap, no daily limit, no list of moves that never happen without a human signature is not autonomous — it is unsupervised. The intelligence is identical either way. The leash is the difference.

The loop has to remember across the gap

A long run outlives the context window, and an agent re-reading its own confused transcript is just a slower way to lose the plot. A human running the loop was also its memory; externalise the loop and that memory has to live somewhere durable — written back to the documents, so a fresh pass starts from the settled facts, not the scrollback. This is where Anthropic's own work on long-running agents lands too: because each session "begins with no memory of what came before," the harness has to carry progress forward in artifacts the next pass can read.

What changes when nobody is watching is the stakes: that same record becomes the only account of what the loop actually did. "What happened, step by step" stops being a debugging nicety and turns into the only way to assign a cause when the outcome surprises you — and a record the agent can quietly overwrite is no record at all.

You stop watching keystrokes and start reading traces

Add these up and the job has a different shape than a year ago. Attention used to be the loop, spent steering each turn. Now it moves to the two ends: design-time, where you specify the goal, wire the honest signal, and set the budget and the leash; and review-time, where you read the trace and decide whether to trust it. The middle — the thousand inner prompts — is no longer yours to watch, and trying to watch it forfeits the point. Which is why the quiet failure, the loop that looked busy for an hour and produced nothing, is so expensive: the cost lands exactly where no one was looking. A long-running agent is not hands-off, whatever the demo suggests — it is hands-on at a different time, before the run and after it.

The loop is only as good as the harness

Prompting did not die. It moved inside the loop, where the model handles it well enough that fussing over each turn is rarely the best use of attention. What sits outside the loop is what now carries the work: a goal a machine can check, a signal a thousand iterations cannot game, a budget and a blast radius, a record that stays honest. That is the harness — and a stronger model only raises its stakes, because it pursues whatever was specified faster and further than the last one did.

So the leverage did not move when agents started looping. It moved to the harness a while ago; looping is what made it impossible to ignore. When you hear that nobody prompts anymore, they just write loops, the true part is that the loop now runs without a human in it — and the part the slogan skips is what it runs on: the goals, the checks, the documents someone still had to write. Prompting didn't die. It moved inside the loop. And the work moved to the harness around it.