Recently, what's the hottest word in Silicon Valley?
Loop.
Open up X, and the entire internet is flooded with discussions about Loop Engineering.
A group of Silicon Valley big shots are abandoning prompts one after another, turning towards autonomous loops!
Jensen Huang has outlined the new focus for the next phase (and a new way to burn tokens):
Nobody writes prompts anymore. The new job is to write and handle loops.
Recently, an Anthropic engineer revealed:
Over 80% of engineers at Anthropic are already using self-improving loops, and it will reach 100% in 3-6 months.
Andrew Ng asserts: In 3 to 6 months, prompts will die! Loops replacing prompts is a foregone conclusion.
Earlier, when explaining his AutoResearch project, Karpathy discussed AI agents' closed loops (generation → execution → evaluation → improve), advocating for partially removing humans from the loop.
In March, Karpathy gave an in-depth interview about AutoResearch / the Karpathy Loop.
OpenClaw's creator, Peter Steinberger, stated bluntly: A monthly reminder, stop manually writing prompts, designing loops is the way.
Claude Code's creator, Boris Cherny, boldly declared: Loop cycling is the future!
Two years ago, we were manually writing code. Then we started transitioning to having agents write code.
Now, we are moving towards a stage where agents prompt other agents, and the latter generates the code.
The step from source code to agents was big, but the significance and impact of introducing a loop mechanism is no less than the previous step.
Who would have thought, after two years of prompt engineering being hot, top AI engineers have moved on.
Why are Silicon Valley big shots so bullish on Loops?
The essence of traditional prompting is: Humans *are* the loop itself.
You write a prompt → Agent outputs → You review → You write the next prompt → Repeat.
Each step relies on human attention, contextual memory, and decision-making bandwidth. The amount of tokens and task complexity one person can effectively drive in a day is limited.
The essence of Loop Engineering is: The system becomes the loop itself.
Therefore, loop engineering is more important than prompt engineering.
Humans only do high-value design once:
1. Define goals and stop conditions
2. Build verification mechanisms (most critical)
3. Establish persistent memory (markdown / external state)
4. Configure discovery and scheduling
Afterwards, the AI loop system can autonomously discover tasks → execute → verify → persist → discover again, running 24/7, with humans only intervening when necessary.
This is why Silicon Valley big shots are all bullish on Loops.
Their judgment is based on this: Once loops mature, the cost-effectiveness of manual prompting will directly collapse!
Loop Engineering 11-page White Paper, Spreading Like Wildfire Online
So, what exactly is the loop process?
In recent days, a white paper on Loop Engineering has started spreading like wildfire on X.
https://drive.google.com/file/d/1qzKI4DKnyHRpXK1J3ATPqwaqLc0iNu-M/view
This 11-page PDF is essentially a popular summary / field guide, compiling relevant public discussions and practical experience.
The core ideas within originate from the public statements of Peter Steinberger, Boris Cherny, and Addy Osmani.
What is Loop Engineering?
Loop Engineering, named by Google Chrome engineer Addy Osmani in June 2026.
It is the fourth layer above prompt engineering, context engineering, and toolchain engineering: the first three layers assume you sit at the keyboard directing the AI line by line; Loop Engineering aims to move you from that position, completely liberating you from the work.
From now on, you are no longer the engine driving the AI, but the architect designing that engine.
The system will automatically wake up at set times, spawn child agents to work, and feed the output back to itself as input for the next round.
The article breaks down a complete Loop into five key actions:
Discovery: The AI uses a solidified skill library to find valuable work on its own, such as reading the latest CI failure logs or unresolved issues.
Handoff: Open independent sandboxes for each task, allowing multiple agents to work in parallel without interference.
Verification: This is the most crucial step. Letting the code-writing AI score itself, it will blindly praise itself. Therefore, a completely independent, default-skeptical "evaluator" agent must be introduced to find faults.
Persist: The AI's memory cannot just stay in a context window that can be cleared anytime. Its state and progress must be solidified to disk so it can continue the next day.
Schedule: Use automation scripts to let the system run autonomously and periodically, closing the entire loop.
Among these, the hardest and most likely to be lazily skipped is verification.
Having the AI score itself, it will almost always praise itself because its mind contains a self-persuasion chain. The solution is to introduce an independent evaluation Agent that assumes the code is bad by default.
However, the system running fully automatically doesn't mean you can rest easy. The author warns: When the loop runs wild late at night, it may quietly accumulate four hidden costs.
Verification Debt: Minor errors not validated are quietly merged into the repository.
Understanding Decay: The AI writes code too fast, causing human understanding of the codebase to seriously fall behind.
Cognitive Surrender: Humans become too lazy to review, accepting AI results wholesale.
Token Runaway: The AI retries all night in an infinite loop, burning through the budget.
The same Loop, built by two different people, may yield completely opposite results. Bring judgment into it, and it amplifies judgment; bring laziness into it, and it amplifies laziness.
In short, this report reveals a profound industry change: Loop engineering makes code generation almost free, while human judgment becomes the only scarce resource!
Also spreading wildly online simultaneously is a 14-step practical handbook issued by Codez, already with millions of shares.
The general idea of the article is as follows: Prompts are outdated, the leverage point has moved up one layer—from "words written for the AI to see" to "designing a system that automatically feeds the AI."
This transformation can be broken down into 14 steps, 3 stages—
First, determine if you really need a loop (Is the task repetitive? Can verification be automated? Can the budget handle it?), then learn the five components (scheduler, isolated working directory, skill files, external connectors, independent evaluation sub-agent), and finally build a minimal viable loop.
The most crucial point among them is: Separate the agent that writes code from the agent that reviews code. The same model acting as both athlete and referee will always give itself full marks.
A loop without objective verification gates is just "two optimists nodding at each other." The better the loop runs, the easier it is for engineers to stop truly understanding the code.
Loop Engineering Birth Timeline
If we were to outline a timeline for loop engineering, it would roughly be as follows.
Early Foundation Stage
2022: Shunyu Yao and others propose the ReAct framework, laying the theoretical cornerstone.
2025: Geoffrey Huntley proposes "Ralph."
2025–Early 2026: Andrej Karpathy releases the AutoResearch project, forming the classic autonomous experiment loop, a major milestone.
Concept Explosion and Naming Stage
Early June 2026, Peter Steinberger speaks out: You shouldn't manually prompt coding agents anymore, you should design loops that prompt them.
Boris Cherny states: I no longer prompt Claude directly, my job is to write loops that run Claude.
June 7, 2026: Addy Osmani publishes the blog post "Loop Engineering," formally naming it, providing a 4-layer stack framework: Prompt → Context → Harness → Loop Engineering.
Subsequently, throughout June, Loop Engineering begins spreading virally across the entire internet.
Claude's "Infinite Loop," Automated Agents Take Over Everything
In an internal podcast, an Anthropic engineer revealed a spine-chilling detail:
When you click run and let Claude execute for 8 hours, you are essentially making a $500 compute power gamble.
If you're still struggling over how to write prompts, you've already lost.
In Anthropic's logic, engineers are evolving into "compute power allocators."
Your core job is no longer writing logic, but deciding where each cent of compute power is invested.
As OpenAI researcher Noam Brown pointed out earlier this month, contemporary models can solve almost any problem if you're willing to throw enough compute power at it.
Loop engineering is part of the big trend of "compute at test time."
Interestingly, the idea of having agents work in loops has actually had prototypes for a while.
At least since last summer, Australian sheep farmer Geoffrey Huntley mentioned a similar approach in his blog, calling it the "Ralph loop."
A year ago, if you wanted to implement a loop, you had to write a bunch of bash scripts and then maintain that code forever, it belonged only to you.
Now, these components are built directly into the products.
You no longer argue about whether to use Codex or Claude Code, but directly design loops that work regardless of which tool you're in.
Former Google engineering and developer relations lead Addy Osmani pointed out that loop engineering requires all the parts that these AI tools already possess.
He also asserts that loop engineering may lead to "cognitive surrender" among engineers:
When the loop runs by itself, you easily stop thinking and just passively accept everything it feeds back.
This is exactly what software engineer Armin Ronacher is worried about.
This is also exactly what is said in the Orange Book, Addy Osmani encourages people to design loops with judgment:
Designing loops, if done with judgment, is the cure; if done to avoid thinking, it is the catalyst—the same action, completely opposite results.
The Loop Endures, Engineering Lives
At the AI Engineer Summit in April, an Anthropic engineer said they tasked Claude with developing a retro mini-game app, using two methods: one using only minimalist prompts, the other using agent loops.
The comparison was stark: The minimalist prompt version took 20 minutes and cost $9; the loop method took 6 hours and cost $200.
But the quality of the app from the latter was far superior.
The former game wouldn't run, the app was crude; the loop version was much richer, containing many features the game designer wanted.
The loop won't pity those who give up thinking. It will only use its speed to turn your ignorance into code debt faster.
And those willing to maintain a clumsy understanding, continuously define rules, and take responsibility for the final results, will gain greater leverage in this paradigm shift than ever before.
Build the loop. Stay the engineer.
Prompt is dead, Loop is running.
And you are still the one who decides its meaning.
References:
https://x.com/DataScienceDojo/status/2069873216152092975
https://x.com/0xCodez/status/2064374643729773029
https://x.com/akshay_pachaar/status/2069769689560187027
This article is from the WeChat public account "新智元" (New Zhiyuan), author: ASI启示录
