# Loop Engineering Went Mainstream Mid-2026, and "[[Loop Engineering|loop engineering]]" is now the phrase you keep seeing in AI conversations. [[Boris Cherny]] from Anthropic (creator of Claude Code) said it directly: "I don't prompt Claude anymore. My job is to create loops." [[Peter Steinberger]] made the same point in his own words: stop prompting coding agents, design the loops that prompt them. [[Jensen Huang]] said something nearly identical. Those posts were the spark. The pile-on since then is the real signal. [[Andrew Ng]] dedicated a letter of The Batch to his three product-development loops. A 19-page Google paper on the topic pulled 670k views in a day on X. [[Matt Van Horn]]'s explainer did 3.6M views and spawned a sequel cataloging the fifteen loops people actually run. GitHub repos now ship CLIs that score your "Loop Readiness". Kent C. Dodds published a video pointing out he's been doing this naturally for months. When the tooling, the curricula, and the "I was doing this before it was cool" videos all show up in the same month, the label has landed. So is this a real evolution or just hype? I think it's both. What [[Simon Willison]] described as "something that runs tools in a loop to achieve a goal" has been the working definition for years. If your reaction to "loop engineering" is "isn't this just agentic design with a new name," you are not wrong. The skeptics land some punches too. The scheduling layer really is just cron. And as the control-theory crowd points out, one stochastic model reviewing another stochastic model is not automatically a control system; we have plenty of loops and not enough control. What cron never had, though, is a decision-maker inside the loop: something that reads the state, acts, checks whether it worked, and decides whether to keep going. That part is new. The rest is plumbing. And the bottleneck actually moved. Claude Opus and Fable now complete tasks with 10+ hour horizons, up from ~1h40 a year ago. Models run long enough and recover reliably enough that the constraint is no longer the model. It's the harness. It's the loop design. Harnesses make a tremendous difference. [[Context Engineering]] took over from prompt engineering a while ago. Loop engineering is the next layer up: the trigger, the tools, the verifier, the stopping condition, the budget. Context still matters, but the way the harness drives the models and tools is where results get decided now. If you are spending most of your AI time crafting individual prompts and almost no time thinking about triggers, verifiers, stopping conditions, and sandboxing, you are missing all the fun. Two things keep that fun honest. First, loops only pay off with a deterministic validation gate. Without one, an agent agreeing with itself on repeat is not autonomous work; it produces wrong answers faster. Second, loops burn money: Uber capped its engineers at $1,500 per AI tool per month after burning through its annual budget in four months. Every loop needs a verifier and a budget. And if human review is already your bottleneck, adding a loop just floods the queue. One more idea worth keeping from Ng's letter: the human doesn't leave the loop, the human moves up a loop. The agent handles the minutes-scale build-test cycle. You handle the hours-scale product decisions and the weeks-scale user feedback. Your advantage is context: you know things about your users the AI doesn't. That, not "taste", is why you stay in the system. I have been tracking this through [[Agentic loops]], [[Harness Engineering]], and [[AI Agent Harnesses (MoC)]] for a while now. The pattern is consistent: the builders who get reliable results from agents are the ones who treat loop design as a first-class engineering problem, not a prompt-quality problem. The label may be new. The lesson is not: design the system, not just the message. ## Update (September 2026): the data is in Three months later, we finally have numbers on how people actually build loops, and they're humbling. A study published on arXiv in August mined 36,710 open-source repositories and confirmed autonomous agent loops in 217 of them. Claude Code runs 87% of those, and almost all of them are triggered by GitHub Actions. What's missing tells the story: no machine-checkable stop condition in the standard vocabulary, no verifier subagent referenced anywhere, no committed budget or cost log, and committed state files in 2 repositories out of 36,645. Everyone talks about verifiers, budgets and durable memory. Almost nobody commits them. Two other papers make the risks concrete. One found 68 confirmed *infinite agentic loops* across 47 agent projects (loops with no effective bound, burning money and repeating side effects). Another found exploitable verifiers in 16% of agent benchmark tasks. So even when you do write a verifier, the agent may find a way around it. Red-team your checks before you trust them. Meanwhile, the tools caught up. Codex has `/goal`, Claude Code has `/goal`, `/loop`, `/schedule`, dynamic workflows and now [[Claude Code Projects]], and Cursor's Ralph plugin ships a detector for loops that spin without making progress. Loops also got cheaper to run: [[Claude Opus 5.5]] finishes command-line tasks with about 40% fewer calls, and [[Decision Models (DMs)|decision models]] like [[Jev]] can answer the small in-loop questions ("is the agent stuck?") in milliseconds. My conclusion hasn't changed, it just has data behind it now: the verifier and the budget ARE the loop. If you only commit the trigger and the prompt, you haven't built a loop. You've built a very persistent cron job. The full picture (studies, tooling, and the critique) is in my [[Loop Engineering]] note. ## References - Andrew Ng, "3 key loops for building 0-to-1 products", The Batch issue 359 (2026-06-26) — https://www.deeplearning.ai/the-batch/issue-359 (LinkedIn: https://www.linkedin.com/posts/andrewyng_loop-engineering-is-a-hot-buzzphrase-after-share-7477753882505338880-dBJ-/) - Matt Van Horn, "WTF Is a Loop? Part 2: The 15 Loops People Are Actually Running" (2026-06-20) — https://www.linkedin.com/pulse/wtf-loop-part-2-15-loops-people-actually-running-steal-matt-van-horn-xgkkc/ - Movez on X (Google 19-page loop engineering PDF: act → observe → learn → repeat) — https://x.com/0xMovez/status/2069500921382326531 - Kent C. Dodds on X ("I've been loop engineering for months") — https://x.com/kentcdodds/status/2069510257525874923 - Austin Marchese, "Stop Prompting Claude. Start Loop Engineering." (YouTube, 2026-06-19) — https://www.youtube.com/watch?v=YAS4ojuhbW4 - cobusgreyling/loop-engineering (patterns, starters, loop-audit CLI) — https://github.com/cobusgreyling/loop-engineering - Simon Willison, "Designing agentic loops" (2025-09-30) — https://simonwillison.net/2025/Sep/30/designing-agentic-loops/ - Anthropic, "Effective harnesses for long-running agents" — https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents - bdtechtalks, "Demystifying loop engineering" (2026-06-22) — https://bdtechtalks.com/2026/06/22/ai-loop-engineering/ - Data Science Dojo, "Agentic Loops: From ReAct to Loop Engineering (2026 Guide)" — https://datasciencedojo.com/blog/agentic-loops-explained-from-react-to-loop-engineering-2026-guide/ - HN: "Designing agentic loops" — https://news.ycombinator.com/item?id=45426680 - Paweł Huryn on X (Cherny / Huang quotes) — https://x.com/PawelHuryn/status/2069315068664197315 - Lulla et al., "Loop Engineering: Building Blocks, Adoption, and Impact" (arXiv, 2026-08-22) — https://arxiv.org/abs/2608.21884 - Hou et al., "When Agents Do Not Stop: Uncovering Infinite Agentic Loops in LLM Agents" (arXiv, 2026-07-02) — https://arxiv.org/abs/2607.01641 - Zhong et al., "Hardening Agent Benchmarks with Adversarial Hacker-Fixer Loops" (arXiv, 2026-06-08) — https://arxiv.org/abs/2606.08960