NextFin News - The next phase of AI coding may not be another smarter model but a different operating pattern: loops. At Meta’s @Scale conference, Boris Cherny, the head of Claude Code, said the industry is moving from hand-written source code to agents writing code, and now to agents prompting agents that keep working in the background. That shift sounds incremental. In practice, it changes who supervises the work, how compute gets spent, and how much trust companies must place in systems that do not stop when a chat window does.
That is why the loop conversation matters now. Single-turn prompting was enough when the job was narrow: answer a question, draft a snippet, explain a bug. But the workload that software teams actually care about is rarely that neat. Real coding work is iterative. It involves architecture, repetition, cleanup, testing, refactoring, and another pass after the first pass exposes a new flaw. A loop gives an AI system permission to keep coming back to the problem until the state of the code, the review, or the repository tells it to stop. The result is a different operating rhythm, one that looks less like chat and more like a machine running a process.
Cherny’s point was not merely that loops are useful. He argued that they mark a step as important as the move from source code to agents. That comparison matters because it places loops in the same category as the first real shift away from human-written code. The industry already knows how to ask a model for help. The harder question is how to structure the work so that one model can supervise another, keep the task alive over time, and improve the result without a human reissuing the same prompt every few minutes.
The attraction is obvious. A loop can keep improving code architecture, find duplicated abstractions, and submit pull requests while the code base changes underneath it. That turns AI from a one-off assistant into a standing workflow. It also makes the system more valuable in places where the work is too fluid for one-shot prompting. If an agent can keep revisiting a code base, inspect changes, and make another pass, the machine is no longer just answering. It is participating in the maintenance cycle.
The danger is equally obvious. A loop also turns AI into an open-ended consumer of tokens, compute, and oversight. Unlike a one-time prompt, it does not come with a neat budget endpoint. A company can start a loop for a sensible reason and end up with something that keeps working simply because it is allowed to keep working. That is why the enterprise debate around loops is not really about novelty. It is about control. The more autonomy the system gets, the more a company has to decide how to cap spend, measure returns, and define a stop condition that is actually meaningful.
Why Loops Matter
Loops matter because they change the unit of work. The first generation of AI coding tools treated the model as a helper: generate text, suggest a fix, explain a snippet, move on. Loops treat the model as a process manager. One agent can look for architecture improvements, another can hunt duplicated abstractions, and a third can keep bouncing the state of the project forward until the job is done or the termination condition is met. That is a much more industrial conception of AI.
The shift is also important because it makes clear how quickly agentic AI is evolving. “Agentic” used to mean a model with tools and a plan. A loop goes one layer deeper. It lets agents talk to agents, and it lets that communication continue beyond a single exchange. Cherny’s description of the transition from source code to agents and then to agents prompting agents captures that change. The human is still present, but now mostly as the architect of the system rather than the executor of each step.
This is why the loop is so compelling in software development. Coding is full of hill-climbing problems: clean up the architecture, reduce duplication, improve tests, tighten the API surface, and repeat. That sort of work does not always benefit from a single brilliant answer. It benefits from many small passes. Loops make those passes cheap to initiate and hard to stop. That is exactly what gives them their power — and their cost.
The loop also helps explain why the AI conversation keeps moving away from prompts and toward workflows. A prompt is a request. A loop is a regime. Once a company adopts loops, it is no longer asking whether the model can produce a useful answer. It is asking whether the model can keep producing useful work under supervision. That is a larger operational question, and it is one reason the feature feels like a real step rather than a cosmetic one.
“Two years ago, we wrote source code by hand. We started to transition so agents write the code. And now we’re transitioning to the point where agents are prompting agents that then write the code,” Boris Cherny said at Meta’s @Scale conference.
“As big as the step from source code to agents was, loops are just as important and as big a step,” Cherny said.
The Economics Of Continuous Work
The economic case for loops is straightforward: if software work is repetitive and uncertain, then letting agents keep working may generate more value than stopping after a single answer. The cost case is just as straightforward: if agents keep working, they keep spending. Cherny’s remarks make it clear that this is already how the industry is thinking about the problem. Some companies frame AI as a cost issue. Others frame it as ROI. He argued that ROI is the better frame, because the point is not to minimize every token at the front door. The point is to find a workflow that pays back enough to justify the spend.
That framing is important because loops are only persuasive when they are tied to a measurable outcome. A loop that improves a code base is not automatically good if it burns through too many tokens to do so. A loop that keeps generating marginal improvements may be technically impressive and economically irrational at the same time. The right question is not whether the loop is busy. It is whether the loop is producing enough incremental value to justify another pass.
Cherny’s advice on deployment reflects that same logic. He said successful companies give tokens to everyone, not just engineers. Product managers, designers, and data scientists should be able to experiment, because useful ideas often come from places the organization would not expect. That is a strong argument for broad access, but it also means the company needs a structure for containment. If everyone can spin up loops, then everyone also needs a way to know how much work the system is allowed to do before it starts to become waste.
He outlined the controls that make that possible: per-seat cost controls, advisor models, company-wide model changes, effort-level settings, and budget controls by department. Those are not minor administrative details. They are the economic architecture of looped AI. They show that the moment continuous work becomes possible, companies also need a way to make that work legible to finance, engineering leadership, and security teams.
The deeper point is that loops do not abolish management. They make management more explicit. A human team can drift, waste time, and still have a naturally bounded day. A loop can remain active as long as the system gives it runway. That makes loops unusually powerful in organizations that are good at measurement and unusually dangerous in organizations that are not.
And because the loop is continuous, it shifts the burden of proof. A single prompt can be judged on its answer. A loop must be judged on its entire run: what changed, how much it cost, and whether the outcome was better than the best alternative. That is a much stricter test. It is also the test that will separate experimentation from serious deployment.
What Changes When Agents Prompt Agents
The novelty in loops is not recursion itself. Software has used recursive logic for decades. The novelty is the decision to let AI manage repeated passes on work that is still changing. That makes loops less deterministic than classic code and more dependent on the judgment built into the system around them. If the stop condition is vague, the loop can wander. If the budget is too loose, the loop can overspend. If the oversight is too strict, the loop loses the very autonomy that made it useful in the first place.
Cherny’s own example shows why the format is catching on. He said he had used 1.7 thousand PRs, added 400,000 lines, deleted 250,000 lines, and used 8 billion tokens since March. He also said 100% of his code has been written by Claude Code since Opus 4.5 and that most of his coding now happens on his phone. Those details matter because they show the workflow in practice, not just in theory. The tool is not simply assisting the developer. It is becoming the medium through which the developer works.
That is also why the discussion of output styles is important. Cherny described an exploratory style, which explains architecture to new engineers while making changes, and a learning style, which walks non-coders through a process instead of doing everything for them. Those are not just convenience settings. They are examples of how loops can be tuned for different organizational goals. One mode is for speed. Another is for education. The same infrastructure can serve both.
This matters because one of the most persistent criticisms of AI adoption is that it can obscure how work is actually done. A loop that only executes may make people faster but less informed. A loop that explains as it goes can preserve understanding while still amplifying output. That distinction will matter in companies where institutional knowledge is part of the moat.
It will also matter because AI coding is increasingly about systems, not demos. The industry can already show agents that write a file or fix a bug. What comes next is harder: keeping agents useful across time, across changing repositories, and across different kinds of users. Loops are one answer to that challenge, but they are also a reminder that autonomy is always partial. The loop still needs a policy, a budget, and a human willing to own the result.
The New Guardrails
If loops are the next phase of agentic AI, then the next competitive advantage may come from governance as much as from model quality. The companies that get this right will not simply allow AI to run longer. They will build rules that let it run longer safely. That means defining when a loop should continue, when it should stop, and how its output should be reviewed once it does.
That governance layer is necessary because the most valuable loop use cases are also the most open-ended. Code architecture can always be improved a little more. Abstractions can often be unified. Tests can be strengthened. Bugs can be chased. In human teams, those tasks naturally stop at the end of a workday, a sprint, or a release cycle. In agentic systems, they only stop if the company makes them stop. That is the critical difference.
Cherny’s comments imply that the industry is already moving toward a new management stack for AI. Budget controls, model-choice controls, effort settings, and role-based access are all part of that stack. So are the workstyles that teach rather than merely execute. The companies most likely to benefit from loops will be the ones that treat these controls as part of the product, not as an afterthought.
That should also change how the market thinks about AI progress. The most important question is no longer whether a model can complete a task once. It is whether a system can keep working on a task long enough to create sustained value without creating runaway cost. That is a more mature framing, and it captures why loops feel like more than just another AI buzzword.
The broader implication is that the next stage of AI adoption may look less like a burst of flashier prompts and more like a slow redesign of how work gets supervised. The winners will be the companies that can keep the loop productive without letting it become directionless. The losers will be the ones that confuse motion for progress.
The loop is powerful because it can keep going. It is valuable only when someone knows why it should stop.
Explore more exclusive insights at nextfin.ai.
