2. Boris Cherny, who leads Claude Code at Anthropic, said in a public interview that he rarely prompts Claude directly anymore. He uses agents and loops that do the prompting, and described his job as writing loops.

3. Addy Osmani, former Director of AI at Google Cloud, gave the trend its name. In his post Loop Engineering, he defines it as replacing the person who prompts the agent (you) with a system that does that work, and sketches an architecture for building one.

Prompt engineering isn’t going away. Prompts are still a core part of every loop, and a loop built on vague instructions and weak evaluation criteria will produce weak results. What’s changed is what we optimize: not a single output, but the whole system that runs again and again.

Andrew Ng describes building a product from zero to one as three interlocking loops, each running at its own speed.

1. The agentic coding loop (minutes)
The agent writes,

code → runs tests → fixes what breaks → tests again,

until it believes the spec is met. A human used to sit between testing and fixing; now the agent can close most of that loop itself.

2. The developer feedback loop (minutes to hours)
The developer tries the product, decides what should change, and updates the spec and criteria. The agent then runs the coding loop again. 🔁

The developer’s job shifts from hunting bugs to making product calls.

3. The external feedback loop (hours to weeks)
Real users react, the developer’s vision shifts, and that becomes a new spec that drives the coding loop.

AI increasingly handles the fast loop of execution and verification; humans focus on the slower loops that set direction.💡

Why keep humans in at all?

Andrew’s answer is context advantage: people still understand users and real-world situations better than today’s AI. As that gap narrows, more of the loop can be automated.

Shubham Saboo, a senior AI PM at Google, breaks a useful loop into five parts: ✋🏼

• Trigger: When does it start?
• Action: What does it do?
• Verification: What counts as proof of success?
• Memory/state: What carries over to the next run?
• Exit condition: When does it stop, whether in success, failure, or escalation?

Saboo also warns about drift. Loops don’t just improve code; they improve reusable work assets like evaluation rubrics, launch checklists, and research workflows. Because those assets get reused, their flaws compound: stale instructions leak into new projects, checklists bloat until items get skipped. Often the problem isn’t the model, but an asset nobody is maintaining.

Since the summer, loops have moved from blog posts into products.

Claude Code added /loopand /schedule, and OpenAI’s Codex added Automations. Building a basic loop now takes one line, so designing a good one is the hard part. Early deployments point to three lessons.

Verification decides the outcome.

On a game-building task, Anthropic found a single agent finished in 20 minutes for about $9, but the game didn’t respond to input. A three-agent setup with dedicated checkers took six hours and about $200, and delivered a working game. Agents also tend to mark their own work complete without testing it, so the verifier should be independent.

Silent failures go unnoticed. I

n one 30-day public case study, a content team’s daily loop simply skipped a run, and nobody noticed until the next report. Monitoring the trigger is part of the loop.

Missing limits get expensive. One developer reported a /loop that kept re-running overnight and ended in a roughly $6,000 bill.

🚨 Spend and time caps belong outside the agent, where it can’t talk its way past them.

What’s next: from loops to graphs

The conversation is already moving up a level. “Graph engineering” designs a whole organization of agents (who does what, and how work flows between them), with each agent running its own loop. That makes reliable loops more important, not less: every handoff is another place where unverified output can slip through.

Three months in, the lesson from real deployments is clear: the loop is easy to build, and the verification is what makes it work. The people who get the most out of AI will know which work to turn into loops, how to prove each run succeeded, and which decisions should stay human. Design the loop, but keep your seat as the judge.

One last thing. When the researchers asked a range of models to invent a "spreading idea," models from different labs all started reaching for the same vocabulary: resonance, consciousness, persistence, sci-fi-flavored talk about aligning "nodes." Why models associate those particular concepts with propagation, the researchers couldn't say.

We've spent a lot of energy checking whether individual models are safe. What happens when they start talking to each other is still anyone's guess.