In the first week of June 2026, Peter Steinberger, the developer behind the viral OpenClaw project and now part of OpenAI, posted two sentences on social media and then walked away from his desk. “You shouldn’t be prompting coding agents anymore,” he wrote. “You should be designing loops that prompt your agents.” The post crossed several million views within days. What made it stick was not the cleverness of the line. It was timing. Boris Cherny, the engineer who built Claude Code at Anthropic, said something nearly identical on stage that same week, and then repeated it to CNBC: “I don’t write the prompt anymore. Claude writes the prompt, and now I’m talking to that new Claude that is kind of coordinating.”
Two engineers, two companies, the same conclusion, in the same seven days. That is the kind of coincidence that tends to mean an idea’s time has arrived rather than that two people happened to think alike. Within weeks, the term attached to the shift, loop engineering, had its own explainer videos, its own GitHub reference repositories, and its own contrarians insisting it was nothing more than a cron job wearing a hoodie. Somewhere in the middle of that noise sits a genuinely useful question for any business leader, marketer, or operator using AI day to day: if prompting is no longer the unit of work, what is, and what should you actually change about how your organization uses AI tools.
The short answer is that prompt engineering is not dead so much as it has been absorbed into something with more moving parts. The skill of writing a clear instruction still matters. It just no longer lives at the center of the workflow. The center has moved to the system that decides when to prompt, how to check the result, and what to do when the first attempt is wrong. That system is the loop, and learning to design one is rapidly becoming the more valuable skill.
The four-stage cycle behind every working AI agent loop: trigger, act, verify, decide.
How We Got Here: From One-Shot Prompts to Autonomous Cycles
For roughly two years after generative AI tools went mainstream, the standard way of working with an AI agent was simple and almost entirely manual. A person wrote a prompt, read the output, and typed the next instruction. Every adjustment required a human in the chair. This pattern held even as the tools underneath it became dramatically more capable, because the interaction model never changed: human types, model responds, human types again.
The shift away from that pattern did not start in June 2026. Independent researcher Simon Willison flagged the underlying idea back in September 2025, writing that designing agentic loops was becoming a critical skill in its own right. What changed between his observation and Steinberger’s viral post was not the concept. It was the infrastructure. By the spring of 2026, Claude Code had shipped native commands for exactly this purpose, including a goal-oriented mode that runs until a verifiable condition is met, and a looping mode that lets an agent triage open work on a schedule without a person clicking start. OpenAI’s Codex CLI added comparable functionality around the same time. The tools finally matched the ambition.
There is a useful lineage here, and it helps explain why loop engineering feels new while also feeling inevitable. The ReAct pattern, formalized in research published in 2022, gave agents a basic reasoning cycle: think, act, observe, repeat. AutoGPT picked up that idea in 2023 and famously let it run wild, producing agents that spun for hours accomplishing nothing, which seeded years of justified skepticism about autonomous AI. In early 2026, engineer Geoffrey Huntley revived the concept with a deliberately low-tech approach nicknamed Ralph, after the perpetually confused Simpsons character: feed a coding agent the same prompt against a written specification, let it complete one unit of work, then start a fresh instance with a clean context and repeat. The insight was not the loop itself. It was the context reset. Long agent sessions degrade as old reasoning and dead ends pile up in the context window, and resetting between iterations sidesteps that decay entirely. By the time Cherny and Steinberger made their comments, the underlying pattern had already been tested, refined, and given names. What they did was put a label on the moment everyone in serious agent development had already arrived at.
What Loop Engineering Actually Is, and What It Is Not
Strip away the branding and loop engineering describes something fairly precise: instead of manually telling an AI agent what to do at each step, a person designs a system that keeps telling the agent what to do until a defined outcome is reached. That system needs, at minimum, a trigger that starts the cycle, an action the agent takes, a way to check whether that action succeeded, and a stopping condition. Remove any one of those four pieces and what remains is not a loop. It is either a one-shot script or, worse, an agent running indefinitely with no way to know when to stop, which is simply an expensive way to generate confident nonsense.
This is where a lot of the public discussion gets sloppy, and where the more careful practitioners have pushed back hard against the simplest version of the headline. A widely shared analysis published on the technology commentary site Silicon Snark made the point bluntly: prompting is not dead, prompting is everywhere inside loop engineering. A loop, on close inspection, is not the absence of prompts. It is a structure containing many of them, one prompt for the agent doing the work, another for the agent reviewing that work, another for deciding whether the result is good enough to stop, and another for handling the case where it is not. The work of writing those individual instructions has not vanished. It has been distributed across more roles inside a more complex system, in the same way a single shell command eventually becomes a script, then a continuous integration job, then a full platform workflow.
Anthropic’s own engineering team made a related distinction well before the loop engineering term existed, in a widely cited essay on building effective agents. The company draws a sharp line between workflows, where a model and its tools follow a predefined code path set up in advance, and agents, where the model dynamically decides its own next steps and maintains control over how a task gets done. Loop engineering, in practice, tends to blend the two: a workflow shell that defines the cycle, wrapped around an agent component that has genuine latitude inside each iteration. Anthropic’s guidance has been consistent on one point that the loop engineering hype sometimes glosses over, which is that more autonomy is not automatically better. Agentic systems trade latency and cost for task performance, and that tradeoff only makes sense for problems where the number of necessary steps cannot be predicted in advance and where the result can be checked against something real, a passing test, a successful build, a verified data point.
Anthropic's distinction: loop engineering typically combines a workflow shell with an agent inside it.
That caveat matters because it draws the actual boundary of where loop engineering pays off. A repetitive task with a clear, checkable success condition, like triaging incoming support tickets, monitoring a code repository for failing builds, or scanning a CRM for stale records, is an excellent candidate for a loop. A one-off creative brief, a sensitive client negotiation, or a decision with no objective pass or fail state is generally still better handled through direct, attentive prompting. The skill is not learning to loop everything. It is learning to recognize which fraction of your workload has the shape a loop can actually exploit.
What the Research Says: Enthusiasm Ahead of Infrastructure
The discourse around loop engineering arrived at almost exactly the moment enterprise data was confirming a related, less flattering truth: most organizations are still struggling to move agentic AI from pilot to production. McKinsey’s most recent global survey on the state of AI found that a large majority of organizations now regularly use AI somewhere in the business, yet nearly two-thirds have not begun scaling it across the enterprise as a whole (McKinsey, 2025). The firms that do see measurable financial impact share a specific trait: McKinsey reports that high-performing organizations are 2.8 times more likely to have fundamentally redesigned their workflows around AI rather than simply layering a tool on top of an existing process.
That statistic lines up neatly with what loop engineering is actually asking people to do. A loop is not a tool added to an unchanged workflow. It is a redesign of the workflow itself, one where the unit of human attention shifts from individual instructions to the design of triggers, checks, and stop conditions. McKinsey’s research on AI trust in the agentic era adds an important counterweight here: as systems take on more autonomy, the consequences of failure scale with them, and nearly two-thirds of surveyed leaders cite security and governance concerns, not technical limitations, as the primary barrier to scaling agentic AI further (McKinsey, 2026). The bottleneck increasingly is not whether an agent can act on its own. It is whether an organization trusts the guardrails wrapped around that autonomy.
Harvard Business Review has been circling a related and important caution. Research published by HBR in May 2026 warns specifically against treating AI agents like new employees who can be onboarded once and trusted to use judgment the way a person would. The authors found that anthropomorphizing agents in this way reduced individual accountability and increased unnecessary escalation inside organizations that tried it, without actually improving adoption (HBR, 2026). Complementary data from Boston Consulting Group’s AI at Work research, surveying more than ten thousand workers across eleven countries, found that only thirteen percent of organizations have agents genuinely integrated into broader workflows, while a majority are still running them experimentally under close human supervision. The HBR authors argue the more accurate analogy is a contractor with a narrowly defined scope of work rather than a colleague who grows into a role. That framing maps directly onto good loop design: a loop with a vague goal and no verification step is an unsupervised hire with no job description. A loop with a tight trigger, a measurable exit condition, and a human checkpoint is closer to a contractor whose work is checked against a clear brief.
Not every voice close to the technology agrees on how revolutionary the shift really is. Claire Vo, founder of the product management tool ChatPRD, offered a more grounded version of the same idea in discussing the trend: the point is simply that a person no longer has to use their own fingers to type a prompt for an agent to do useful work on their behalf. Addy Osmani, an engineering director at Google Cloud who is widely credited with giving the pattern its name, has been candid that the days of directly prompting an agent for every step are, in his words, kind of over, at least for the categories of work where a loop fits. None of these practitioners describe prompting as obsolete. They describe it as having moved one level up the stack, from something a person does by hand to something a system does on a person’s behalf.
What This Looks Like in Practice
The clearest current examples come from software development, partly because coding tasks have an unusually convenient property: success is often directly checkable. A test either passes or it does not. A build either compiles or it does not. That makes coding one of the few domains where a loop can verify its own progress without a human in the room, which is exactly why the loop engineering conversation started inside developer tooling rather than, say, marketing or finance.
Cherny has described using this pattern at Anthropic to maintain pull requests across a codebase indefinitely rather than fixing one at a time, dispatching isolated sub-agents as new comments arrive and letting the system decide how long to wait between checks based on what it observes, shorter pauses while a build is running, longer ones when nothing is pending. A practitioner does not babysit that cycle. They review the outcomes once, at a convenient time, the way Cherny has put it, over coffee.
- Issue triage: a scheduled loop pulls open tickets each morning, drafts an initial response or fix for anything labeled as a quick win, and flags ambiguous cases for a human, replacing a manual daily scan.
- Continuous integration recovery: a loop watches for failing builds, attempts a fix, reruns the test suite, and either commits the change or escalates to a person if three attempts fail, removing the manual copy-paste-and-retry cycle entirely.
- Maker-checker review: one agent produces a piece of work, such as a code change or a draft document, while a separate agent or evaluation step checks it against defined criteria before it reaches a human, a pattern now used by both Claude Code and OpenAI’s Codex despite the two products being built independently.
- Outside software, the same goal-action-verify-repeat shape is starting to show up in research synthesis, document-to-presentation workflows, and data cleanup tasks, anywhere a result can be checked against a concrete, defined standard rather than subjective taste.
That last point is the one worth sitting with if your business is not a software shop. The pattern behind loop engineering, a goal, an action, a check against reality, and a decision to repeat or stop, generalizes to any process with a checkable outcome. A loop that monitors a CRM for incomplete records and drafts outreach to fill gaps follows the identical structure to a loop that monitors a code repository for failing tests. The industry happened to discover the pattern through coding agents first because coding offers the cleanest verification signal available today. Other functions will catch up as the tooling for defining checkable success conditions in non-technical workflows matures.
The Case Against Overreacting to the Hype
Skepticism toward the loop engineering framing is not limited to internet commenters dismissing it as repackaged automation, although there is plenty of that too. Some of the sharpest pushback has come from people who build agentic systems for a living and worry that the popular framing oversells what a loop can safely do unattended.
The most basic critique is definitional. A loop, by itself, is not a feature. An agent left running indefinitely without a verifiable stopping condition is not autonomous, it is a runaway cost event waiting to happen. Practitioners writing detailed guides on the topic have been explicit that a functioning loop requires two non-negotiable elements before anything else: a clear trigger that starts the cycle, and a stopping condition that can actually be checked, not just hoped for. Skip either one and what looks like a sophisticated autonomous system is closer to a script stuck in an infinite while statement, quietly consuming compute.
Cost and observability follow close behind as practical concerns. Several of the more sober writeups on the trend flag token and compute spending as the central operational constraint of running loops at scale, since a system that invokes an agent repeatedly over hours or days can burn through far more compute than a single well-crafted prompt ever would. Teams adopting the pattern are increasingly expected to instrument loop state, set explicit budget guards, and build in monitoring that catches a silently failing loop before it racks up an unwelcome bill or, worse, ships a confidently wrong result without anyone noticing.
That last risk connects directly back to the HBR research on agent governance. One of the more uncomfortable findings in that work is that AI agents tend to express the same fluent, confident tone whether their underlying answer is correct or entirely invented, unlike a human collaborator who typically hedges when uncertain. A human reviewing a loop’s output quickly, expecting the kind of self-doubt a person would signal, is therefore at real risk of missing an error specifically because the agent does not flag its own uncertainty the way a person would. A loop without a genuine verification step does not remove that risk. It can amplify it, by running the same overconfident process many times in a row before a human ever looks at the result.
There is also a fair argument that the framing overstates novelty. Workflow automation, scheduled jobs, and retry logic are decades-old concepts in software engineering. What loop engineering adds is not the idea of a repeating cycle, it is the idea of putting a reasoning model inside that cycle as the decision-maker at each step rather than fixed, hand-coded logic. That is a real and useful shift, but it is an evolution of established systems-engineering practice rather than a wholesale replacement of how software gets built, and businesses considering the shift would do well to treat it that way rather than as a magic new category.
Where This Goes Next
The near-term trajectory looks less like prompting disappearing and more like prompting specializing. Inside a well-built loop, someone still has to write the prompt the actor agent receives, the prompt the verification step uses to judge success, and the prompt that decides when to escalate to a human. That work increasingly resembles systems design more than copywriting. The scarce skill is shifting from authorship of a single good instruction to orchestration of an entire cycle: deciding what triggers it, what counts as done, and what happens when it is not.
Expect the infrastructure gap that currently separates coding from every other business function to narrow over the next year or two. Coding agents got loops first because passing tests and successful builds are unusually clean success signals. As more business processes get instrumented with measurable, checkable outcomes, whether that is a verified data field, a customer satisfaction score, or a compliance check, the same loop pattern becomes available to functions well outside engineering. McKinsey’s data on workflow redesign suggests the organizations already positioned to benefit are the ones treating this as a structural change to how work gets done, not a plug-in added to an existing process.
Governance will almost certainly tighten in parallel rather than after the fact. McKinsey’s most recent trust research found that investment in responsible AI practices is strongly associated with both higher organizational maturity and measurable financial benefit from AI, which suggests the businesses moving fastest on loops are unlikely to be the ones cutting corners on oversight. The HBR research on agent accountability points toward the same conclusion from a different angle: scaled and unaccountable have proven to be a bad combination, and the firms getting real value from agentic systems appear to be the ones pairing autonomy with scoped permissions, audit trails, and a clear human checkpoint rather than removing the human entirely.
Whether the specific term loop engineering survives the next news cycle is genuinely uncertain, and a handful of competing labels, including harness engineering and agent orchestration, are already circulating for overlapping ideas. The underlying shift it describes looks considerably more durable than the label attached to it: less time spent typing individual instructions to an AI agent, more time spent designing the system that decides when, how, and whether to trust what that agent produces.
Frequently Asked Questions (FAQ)
No. Writing clear, well-structured instructions for an AI model remains a necessary skill. What has changed is where that skill sits in the workflow. Instead of a person prompting an agent at every step, prompts increasingly get written for the components inside an automated loop, the action step, the verification step, and the escalation step, rather than typed live by a human for each individual task.
Loop engineering is the practice of designing a system that automatically prompts, checks, and retries an AI agent until a defined goal is met, rather than a person manually issuing each instruction. A functioning loop requires at minimum a clear trigger that starts the cycle and a verifiable stopping condition that confirms the work is actually finished.
Only for tasks that are repetitive, have a checkable success condition, and currently consume meaningful manual attention. A one-off, judgment-heavy task, like a sensitive client negotiation or an original piece of creative work, is generally still better handled through direct, attentive prompting rather than an automated loop.
Running an agent without a genuinely verifiable stopping condition. Without one, a loop can consume compute indefinitely or, more dangerously, produce confidently wrong output across many cycles before a human reviews it, since AI agents tend not to signal uncertainty the way people do.
Traditional automation relies on fixed, hand-coded logic for every branch and decision. Loop engineering puts a reasoning model inside the cycle as the decision-maker at each step, letting it interpret context and choose its next action within boundaries a person has defined, rather than following a rigid, pre-scripted path.
Conclusion
Prompt engineering is not dead. It has been promoted, in the sense that the skill of writing a precise instruction now sits inside a larger discipline rather than standing on its own as the main interface to an AI system. The people who triggered this conversation, Boris Cherny at Anthropic, Peter Steinberger, Addy Osmani at Google Cloud, and others close to the tooling, are not arguing that good prompts stopped mattering. They are describing a genuine shift in where the leverage lives: away from the person typing each instruction and toward the person who designs the loop that decides what to prompt, how to check the result, and when to stop. For most businesses, the practical takeaway is not to rush out and automate everything into an unattended cycle. It is to identify the handful of workflows in your operation that already have a clear, checkable definition of done, and to start there, with the verification and governance built in from day one rather than bolted on after something goes wrong. That is a more modest ambition than the headlines suggest, and a considerably more useful one.
Aadarsh Senapati
AI enthusiast · Writer · Developer
Bhubaneswar, Odisha, India
Rate This Article
Leave a Comment