The Prompt Was Never the Unit of Work.
ChatGTP got really big in late 2022. We’ve spent the last four years, then, optimising the single message: the perfect, magical system prompt. For anyone that can remember back that far, we spent a long time on 600-word system prompts.
Loop engineering is the realisation that this was never the job. The job is the the loop that our single message lives inside:
trigger - act - check - decide - repeat
Prompt engineering is one go around of this. Loop engineering is designing a system that runs thousands of them on your behalf, without you present. Devs doing it this way are getting 10x out of agents over even the most sophisticated of ‘single-prompters’ working five concurrent claude tmux windows.
The devs doing it this way kicked off a loop, walked away, and came back to a finished, self-validated PR.
Prompt engineering optimized a sentence. The job was always the loop.
The old mental model felt complete: one input (your prompt) led to one output (new code), then you tuned that output. At first you might even have done manual edits to the output yourself (that’s so 2023). This is how we adopt new tech, to be fair. We do the existing thing but just faster, perhaps with one step taken care of by the machine. The biggest limiting factor in this workflow was the quality of the model.
In 2026, agents now run multi-step tasks autonomously for hours, so the bottleneck moved from model capability to orchestration design. Given that there’s little practical limit on the number of agents, and the complexity of a workflow, and that now LLM outputs are generally pretty solid, the orchestration becomes the competitive differentiator.
This is where loops come in.
The term "loop engineering" went mainstream just this month (June 2026) after Peter Steinberger, Boris Cherny, and Addy Osmani all pointed at the same shift.
Defined it in one clean sentence: loop engineering is designing the system that prompts, verifies, retries, and stops the agent so you're not in the chair turn by turn.
A loop has six dials. Most people only touch one.
There are six components to a loop:
Trigger: what kicks the loop off (a failing test, a webhook, a cron, a Linear ticket moving to "ready"). For most devs, it’s only ever "me, typing."
Context: what the agent gets each pass (the diff, the failing test output, the relevant files, but not the whole repo). This ties back to context engineering: curate, don't cram.
Tools: what it can actually do (run tests, grep, hit a staging API, open a PR). The loop is only as capable as its tool list.
Verification: the checkpoint that decides pass/fail (tests green? typecheck clean? a second agent reviewing intent?). This is the dial that makes a loop trustworthy instead of a runaway.
State: what persists between passes (a scratchpad file, a task list, a running summary). Without it, every pass is amnesiac.
Stop condition: when it ends: success, max retries, cost ceiling, or "escalate to a human." The most-skipped dial, and the one that saves you a $40 token bill at 2am.
The trap: a loop without a brake can become a runaway train
Verification and stop conditions are non-negotiable: an unverified loop ships slop at machine speed (callback to The Sloppening if useful).
Cost + blast radius: scope tokens, scope permissions, never give an autonomous loop ambient prod access.
The honest caveat: not every task wants a loop. One-shot questions don't. Loops earn their keep on repeatable, verifiable, multi-step work.
Action steps (do this week)
Pick one task you currently babysit an agent through (test repair, dependency bumps, lint cleanup).
Write down its six dials explicitly: trigger, context, tools, verification, state, stop.
Add the one dial you're missing (it's almost always verification or stop condition).
Run it unattended once. Watch where it goes wrong. That failure is your loop design feedback.
The toolkit
This week features the debut of the temrel-agentic-toolkit, an open-source collection of small agentic engineering tools and skills that grows by one item each issue.
Why this matters
In terms of your career, this is a reframe: last year’s differentiator was being a context engineer. Loop engineer is this year’s rung. Show your organisation that you can build and manage loops that are trustable.
As agents run longer and longer unattended, the seperation between devs ceases to be who writes the best prompt and becomes who designs the best loop. The prompt was never the unit of work. Now the top engineers can see it.
See you next Monday.
