"Stop prompting the agent — design the system that prompts it." Three people independently reached the same phrase within one week of June 2026. A new layer in the stack 🔁 Title: Loop Engineering: The Anthropic Playbook for Designing Systems That Prompt Your Agents URL: A field note defining loop engineering as the 4th layer above prompt→context→harness, decomposed into five moves, six parts, and four costs. Three highlights. 🔁 Move yourself OUTSIDE the loop Earlier terms assumed a human at the keyboard prompting line by line. Loop engineering deletes that assumption, shifting you from being the engine to designing it. It wakes on a timer, spawns sub-agents, and feeds its own output back as the next input — that cross-conversation memory is what makes it a loop, not a one-off rerun. 🛑 The hard part is verification that can say "no" Ask an agent to grade its own output and it praises it. So rather than making the generator self-critical, you tune an independent skeptical evaluator on a different model — one that doesn't just read but acts (e.g. via Playwright) to verify. Claude Code's /goal lets a fresh small model judge the stop condition (the bank maker-checker principle). 💎 Generation is nearly free; judgment is the scarce resource Code, PRs, and fixes become abundant; value concentrates in deciding which one is actually right. Stripe merges 1,300+ machine-written PRs a week, yet reliability comes from constraint quality, not model size — and humans still review every PR. The closing line lands: the same loop, built by two people, can yield opposite outcomes. #AIAgents# #LoopEngineering#

Loop engineering has emerged as a new skill for AI engineers But there is very little research measuring how effective it is. The best results on full tasks in a new benchmark is ~25%. LoopArena from AMAP evaluates the outer loop rather than the coding agent. A Controller model receives a structured summary after each round and instructs a separate fixed Worker agent on what to do or verify next, or decides to stop. Holding the Worker constant makes the result readable, since an end-to-end run cannot tell you whether success came from the guidance or from the agent carrying it out. The named failure modes will be familiar to anyone running long agent sessions: - Trusting a stale progress note - Skipping needed verification - Spending budget in the wrong direction - Stopping before the task is safe to submit Paper: Chat with Paper:

“Loop engineering” is a hot buzzphrase after mentions of it by Boris Cherny (Claude Code’s creator) and Peter Steinberger (OpenClaw's creator) went viral on social media. Loops are now a key part of how we get AI agents to iterate at length to build software. In this letter, I’d like to share my 3 key loops, shown in the image below, for building 0-to-1 products. These loops guide not just how I build software, but also how I decide what software to build. Agentic coding loop: Given a product specification and optionally a set of evals (that is, a dataset against which to measure performance), we can have an AI agent write code, test its work, and keep iterating until the code is bug-free and meets its specification. This idea of closing the loop took off around the end of last year, and it has been a game changer in enabling coding agents to work longer productively without human intervention. For example, over the weekend, I was building an app for my daughter to practice typing, and my coding agent could easily work for around an hour, using a web browser to check what it had built multiple times before getting back to me, without needing my intervention. The engineering loop executes quickly. Every few minutes, the coding agent might build and test a new version of the software. I hear frequently from developers who are finding new ways to engineer more effective engineering loops. This is an active area of invention! Developer feedback loop: In this loop, a developer examines the current product and steers the coding agent to improve it. Last year, a lot of developers (including me) were acting as the QA (quality assurance) function for our coding agents, manually finding bugs and then asking the agent to fix them. But with coding agents much more able to test their own code, the amount of time we need to spend on this function has decreased significantly. This allows us to make higher-level product decisions, such as what key features to offer, where the UI needs improvement, and so on. The developer-feedback loop operates over time intervals between tens of minutes and hours — that's how frequently a developer might review a product and give feedback. In the case of the typing app, I changed my mind a few times about the visual design, what cat costumes she can unlock as she learns (she loves cats), and the user flow for a grown-up to log in and steer the child's learning experience. When a developer has a clear vision for what to build, it is still a lot of work to translate that vision into a specification for a coding agent to implement. Further, after the developer has seen an implementation, they might update (or perhaps clarify) the spec to steer it toward what they want. If you find that the system repeatedly runs into certain problems, building a set of evals for the agent becomes useful. AI-native teams are increasingly using AI to help shape product direction, for example, automating the gathering and analysis of usage data, summarizing written and verbal customer feedback, or carrying out competitive analysis. However, for pretty much all the products I’m involved in, I see humans as having a significant context advantage over current AI systems — we know a lot more than the AI system about the users and the context the product has to operate in — and thus humans play a critical role. Many people describe this human contribution as “taste,” but I prefer to think of it as humans having a context advantage, since that gives us a clearer path to helping AI systems get better. This also speaks to why this step can’t be automated: So long as the human knows something the AI does not, human-in-the-loop is needed to to inject that knowledge into the system. External feedback loop: This includes a wide range of tactics like asking a few friends for feedback, launching to alpha testers, or putting the code into production with A/B testing. These tactics are usually slow, rarely taking less than hours and sometimes taking days or even weeks. This data informs the developer vision, which in turn continues to drive the detailed product spec, which in turn drives the coding agent. With coding agents speeding up software development, more engineers are starting to play a partial product management role. For many engineers who are growing into this role, the hardest part is shaping the product vision and striking a balance between building (bridging the gap between vision and spec) and getting user feedback to evolve the vision. It is important to do both! I will write more about how to do this in future posts, but for now, I find it encouraging that engineers are playing an expanded role (just as product managers and designers now do more engineering). [Original text: The Batch]

You really don't need "software factory" or "loop engineering" to work effectively, or in this case burn $10K per month on a subscription of $200/month. A few very simple tips: * make every ticket ready to start -- pay attention to the grooming and design phase of any task -- ruthlessly delete tickets; * set up a separate repo for the OS that's different than the code repo -- this repo stores working agreements, workflows, learnings, docs. Keep the code repo(s) clean and dry -- pure code and nothing else. * always start working from the OS repo: OS + linear tickets == durable work context. Code is just a short-lived artifact * if you actually need to use goals, write them down in the OS first and then issue them to agents. * don't ever read code, but design a few "gates" your agent have to go through. For me: pixel gate for me to review UX, code review gate(automatic), release gate (automatic). * Design your "squad" -- a group of agents together doing one task. One squad for one complete epic. Tickets should be filed at squad level, such as "finish onboarding v2", not at task level, like "add a button to onboarding". -- 过去的 30 天其实没有用任何所谓的“软件工厂”/loop/graph，就是遵照一些基本的软件工程的原则，默默地就烧掉了 13B 的 tokens，折合 API 价格 $10110. 就是几个很普通的原则如上

If you’re not using a harness with your squad to do loop engineering, are you falling behind? If that sentence made you go 🤯, you’ll want to check out the latest GitHub Podcast episode, where we break down the AI lingo developers are hearing right now. Get it wherever you listen to podcasts or find it here

Thanks to @whoisnnamdi and @Lightspeedvp for the shout-out to LLM-as-a-Verifier on the Lightwork podcast! Check out the episode for a great explanation of "loop engineering" and agent verification:

New blog post 📝 "Buzzword Engineering" Prompt Engineering, Context Engineering, Harness Engineering, and now Loop Engineering — at least four "Engineerings" have been born in just a few years since LLMs arrived. Why does the next name keep arriving before the previous one has matured into a real methodology? 🤔 In this post, I name and dissect this phenomenon: Buzzword Engineering — a mode of knowledge production in which methodologies are named and shipped faster than verification can digest them. The root cause is an asymmetry of speed. LLMs drove the cost of proposing methodologies to nearly zero, and are even becoming proposers themselves. Verification, however, completes only when products are used by real users — it remains rate-limited by human behavior. Proposals move at machine speed; verification moves at human speed. Names pile up in the gap as a backlog ⚙️ But this is not a piece that sneers at buzzwords. As Schumpeter's "swarms" and the hype cycle show, proliferation is written into the standard timetable of every technological revolution — it is the first step of knowledge creation, coordinating the attention of engineers worldwide. What I propose instead is a gearbox connecting two clocks: the weekly clock of methodology and the yearly clock of product value. That gearbox is xOps. Inside it: evaluation assets that compound over time, an "autonomy budget" for operating agent delegation by observation, and one norm — if you coin a name, attach falsification conditions and an eval. Methodologies depreciate; evaluation assets compound 🚀 If you're tired of chasing new names, this one is for you. #BuzzwordEngineering# #TechTrends#

Thariq Shihipar (@trq212) is an engineer on Anthropic’s Claude Code team I asked him how Anthropic makes the most out of the models for engineering and how the industry will change soon. In this episode: • Internal best practices in leveraging the models • What percent of Anthropic's work is fully autonomous • How Anthropic maintains higher volumes of code • What has worked in preventing AI-written breakages Where to watch: • YouTube - • Spotify - • Apple Podcasts - • Transcript - Thank you to the sponsor of this episode for supporting my work: • WorkOS: makes your app Enterprise Ready with easy to use APIs to add SSO, SCIM, RBAC, and more in just a few lines of code, check them out at Chapters: 00:00 Intro 00:29 Onboarding at Anthropic 02:53 Internal capabilities vs external perception 06:16 Model vs Harness 08:55 What percent of Anthropics changes are fully autonomous 14:51 Computer use 17:42 How to make the most out of your compute 20:45 Loop engineering 22:47 Where the industry will go soon 26:02 Which model do Anthropic engineers use 27:38 Is learning a particular model worth it 30:56 Prompting tips for todays models 35:04 How to get the models to do tasteful work 39:00 How much of writing is done by AI at Anthropic 45:36 Code ownership and maintenance at Anthropic 52:04 How Anthropic prevents breakages 55:24 Visibility and sharing your work 58:42 Luck surface area example 01:00:57 Should people still learn to code 01:07:42 Advice for his younger self 01:09:58 Outro