If you've been anywhere near AI coding Twitter in the last few weeks you've seen the phrase everywhere: loop engineering. Suddenly everybody's an expert, every newsletter has a guide, and the general vibe is that if you're still typing prompts into Claude Code like a peasant, you're already obsolete. So let me do what I do, cut through the hype, tell you what this actually is, what's genuinely real about it, and what's just the AI crowd doing what the AI crowd does, which is turning a reasonable idea into a religion overnight. Because there's something actually real here worth understanding, it's just buried under a pile of breathless takes.
Where this came from… like two weeks ago
All this is genuinely brand new. On June 7th, 2026, Peter Steinberger posted two sentences that hit 6.5 million views on Twitter: you shouldn't be prompting coding agents anymore, you should be designing loops that prompt your agents. That was it. No diagram, no repo, just six words of provocation, and the entire AI coding world spent the next week arguing about what it meant. Around the same time Boris Cherny, the man who created Claude Code, said basically the same thing: “I don't prompt Claude anymore, I have loops that are running, they're the ones prompting Claude, my job is to write loops."
When the creator of Claude Code and a guy with millions of followers both say the same thing in the same week, the AI internet loses its mind, and it did. A week later "loop engineering" was trending with thousands of posts, hailed by some, mocked by others, and joked about by everyone who's watched Claude say "you're right to push back" for the thousandth time. So just know, when somebody acts like loop engineering is some deep established discipline you're behind on, the term is about two weeks old. Nobody's an expert yet. Calm down.
Okay so what actually is a loop?
Strip away the hype and it's pretty simple, which is good, because simple is usually what separates the real from the fake. A loop is the cycle behind every reliable AI agent: do something, observe the result, decide what to do next, and repeat until the goal is actually met. That's it. Act, check, decide, repeat. It's the same OODA loop fighter pilots talk about, just pointed at your codebase.
The old way: you type a prompt, the agent does its thing, it stops, you look at it, you type another prompt. You're the loop. You're the person checking the result and deciding what's next, over and over, manually, all day. Loop engineering says: you stop being the loop. Write a program that does the checking and deciding for you, so the agent runs on its own against real signals, tests passing, types checking, linter happy, and keeps going until the actual goal is met instead of stopping every thirty seconds to ask you what's next. It's the latest layer in a progression: prompt engineering, then context engineering, then harness engineering, and now the loop itself. Your job moves from operator to architect. You stop driving and start building the thing that drives.
And it's not just a concept, the tools shipped it. Claude Code ships a /loop command, Codex has /goal, where you set a durable objective and a separate evaluator model checks whether the goal is actually met at the end of each turn and only stops when it passes. Boris's example everyone copies is literally "/loop babysit all my PRs," set it loose and it auto-fixes build issues and handles review comments while you do something else. One documented run went 25 hours straight, burned 13 million tokens, and cranked out 30,000 lines of code. Unsupervised. While the guy presumably slept.
The honest skeptic take
Now let me give you the other side, because the backlash to the hype is actually pretty funny and pretty correct. The best skeptical line in the whole pile was someone pointing out that every AI agent they shipped this year is a for-loop, an LLM call, and a try/catch around the JSON parsing, and the only thing agentic about it is the Anthropic bill at the end of the month. And that's not wrong. At its core, a loop is just cron plus a decision-maker in the body. We invented running things on a timer in like 1975. If your entire definition of loop engineering is "something that runs on a schedule," congratulations, you reinvented the cron job and gave it a LinkedIn-friendly name.
So part of the loop engineering hype is exactly the thing this whole blog keeps warning about: the AI world loves to take a sensible practical idea, slap a Serious Term on it, and act like a new era began. Prompt engineering, context engineering, harness engineering, now loop engineering, every few months there's a new -engineering you're supposedly failing at. A lot of that is just content mills needing something to write guides about. Don't let the buzzword make you feel behind. The underlying idea is real and useful. The "you're obsolete if you're not doing this" doom posting is mostly noise.
The part that's genuinely real
Okay, now let me be fair, because there IS a real shift underneath the hype and you should actually get it. The interesting engineering isn't the loop itself, the loop is trivial. The interesting part is everything you wrap around the decision so it doesn't run off a cliff. That's where the actual skill is, and it's not nothing.
Think about what can go wrong when you let an agent run unsupervised for 25 hours. It can loop forever and never decide it's done. It can convince itself it succeeded when it didn't, hallucinating progress. It can read a malicious web page or file that hijacks what it does next. And it can quietly burn through your entire budget while you sleep. The standard guardrails everyone converges on are strong termination logic so it actually stops, a separate evaluator so the agent grading the work isn't the same one that did it, and sandboxing because every file and web page the loop reads is untrusted input that could carry a prompt injection. That separation point, one agent proposes and a different agent checks, is the same cross-review idea I've harped on before, and it's one of the most powerful reliability patterns there is, because the model that wrote the code is the worst possible judge of whether it's right.
And the cost thing is the part that should really get your attention, because it ties directly to everything I've been saying about AI bills. Once the model writes code for almost nothing, the expensive resource shifts from tokens-per-feature to managing the loop, and the failure mode every team fears is the loop that doesn't stop, which produces billing surprises orders of magnitude over budget. This is why Uber capped its engineers at $1,500 per person per tool per month after burning its whole annual AI budget in four months. A runaway loop is a money fire. The guardrail that makes it stop isn't a nice-to-have, it's the thing standing between you and a five-figure surprise invoice. The models just aren't good enough yet for me to completely trust them on a loop… well, at least for complex tasks.
So should you actually care
Here's my honest read. If you're a casual vibe coder building small stuff, you do not need to go architect autonomous 25-hour loops right now, and anybody making you feel behind for not doing it is selling a course. Even the loop engineering writeups admit most developers don't need agent loops yet. Keep prompting, keep shipping, you're fine. The fancy loop stuff is for when you've got repetitive, well-defined, verifiable tasks worth automating, like babysitting PRs or grinding through a big migration, not for "build me a startup while I sleep."
But the core idea is worth absorbing even if you never write a single /loop command, because it points at where this is all going. The skill is moving from "how do I prompt the agent well" to "how do I set up the agent to run well on its own and know when it's actually done." Even in your normal day-to-day, thinking about clear goals, real success checks, and hard stops will make you better with these tools. You don't have to drink the kool-aid and call yourself a loop engineer on LinkedIn next week. Just understand that the verification and the guardrails are the actual craft, the loop is just a while statement, and the people who win with this stuff are the ones who get the agent to reliably know when it's done and when to quit, not the ones who tweet about it the loudest. Learn the real part, skip the hype, and check your billing dashboard before you let anything run for 25 hours.
Sources
explainx.ai: Loop Engineering for Coding Agents - The June 7, 2026 Peter Steinberger tweet that hit 6.5 million views and coined the framing, the lineage of the term, and the skeptical "for-loop plus an LLM call plus the Anthropic bill" take.
Data Science Dojo: Agentic Loops from ReAct to Loop Engineering - Boris Cherny's "I don't prompt Claude anymore, I write loops" quote, the /loop and /goal commands with their evaluator mechanic, and the documented 25-hour, 13-million-token, 30,000-line run.
HappyCapy: Loop Engineering for AI Agents - The plain definition of the act-observe-decide-repeat loop, the standard failure modes, and the core guardrails of termination logic, a separate evaluator, and sandboxing against prompt injection.
Tosea: What Is Loop Engineering - The four-step progression from prompt to context to harness to loop engineering, and the admission that most developers do not need agent loops yet.
Dev.to: The Agentic Loop Field Guide - The point that cost shifts from writing code to managing the loop, the runaway-loop billing-surprise failure mode, and Uber capping engineers at $1,500 per tool per month.
explainx.ai: What Is Loop Engineering - The rapid spread of the term across X within a week, championed by Cherny and Steinberger and critiqued by others, as the latest evolution after prompt engineering.
