Jensen Huang: The Prompt is dead, and the entire AI industry is going all-in on the Loop.

Recently, what's the hottest term in Silicon Valley?

Loop.

As soon as you open X, the entire internet is flooded with discussions about Loop Engineering.

A bunch of Silicon Valley bigwigs are all giving up prompts and turning to autonomous loops!

Jensen Huang has pointed out the new focus for the next stage (also a new way to burn tokens):

Nobody writes prompts anymore. The new job is to write and handle loops.

(No one writes prompts anymore. The new job is to write and manage Loops.)

Recently, an engineer from Anthropic revealed:

Over 80% of engineers at Anthropic are already using self-improving loops, and this will reach 100% in 3 - 6 months.

Andrew Ng asserted that in 3 to 6 months, prompts will become obsolete! It's a foregone conclusion that Loops will replace prompts.

Karpathy, when explaining his AutoResearch project, discussed the closed loop of AI agents (generation → execution → evaluation → improve) and called for partially removing humans from the loop.

In an interview in March, Karpathy specifically delved into AutoResearch / Karpathy Loop.

Peter Steinberger, the father of OpenClaw, said bluntly: A monthly reminder, stop writing prompts by hand. Designing loops is the way to go.

Boris Cherny, the father of Claude Code, boldly declared: Loops are the future!

Two years ago, we were still writing code manually. Later, we started transitioning to having agents write code.

Now, we're moving towards a stage where agents prompt other agents, and the latter generate code.

The leap from source code to agents is significant, but the significance and impact of introducing the loop mechanism are no less than the previous step.

Unexpectedly, after two years of the popularity of prompt engineering, top AI engineers have moved on.

Why do Silicon Valley bigwigs all favor Loop?

The essence of traditional prompting is that humans are the loop itself.

You write a prompt → the agent outputs → you review → you write the next prompt → and so on in a loop.

Each step depends on human attention, context memory, and decision - making bandwidth. The amount of tokens and the complexity of tasks that a person can effectively drive in a day are limited.

The essence of Loop Engineering is that the system itself becomes the loop.

Therefore, loop engineering is more important than prompt engineering.

Humans only need to do one high - value design:

1. Define the goal and stop conditions.

2. Build a verification mechanism (the most crucial).

3. Establish persistent memory (markdown / external state).

4. Configure discovery and scheduling.

After that, the AI loop system can autonomously discover tasks → execute → verify → persist → discover again, running 24/7, and humans only intervene when necessary.

This is why Silicon Valley bigwigs are all bullish on Loops.

They base their judgment on this: Once loops mature, the cost - effectiveness of manual prompts will collapse!

The 11 - page white paper on Loop Engineering is going viral across the internet

So, what exactly is the loop process?

In recent days, a white paper on Loop Engineering has been going viral on X.

https://drive.google.com/file/d/1qzKI4DKnyHRpXK1J3ATPqwaqLc0iNu-M/view

This 11 - page PDF is essentially a popular summary/on - site guide, gathering relevant public discussions and practical experiences.

The core ideas in it stem from the public statements of Peter Steinberger, Boris Cherny, and Addy Osmani.

What is loop engineering?

Loop Engineering was 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 that you're sitting in front of the keyboard, directing the AI line by line. Loop Engineering aims to remove you from this position and completely liberate you from the labor.

From now on, you're no longer the engine driving the AI, but the architect designing this engine.

The system will automatically wake up at the set time, spawn sub - agents to work, and feed the output results back to itself as the input for the next round.

The article breaks down a complete loop into five key actions:

Discovery: The AI uses its solidified skill library to find valuable work on its own, such as reading the latest CI failure records or unresolved issues.

Handover: Open an independent sandbox for each task, allowing multiple agents to work in parallel without interference.

Verification: This is the most crucial step. If you let the AI that writes code grade itself, it will blindly praise itself. Therefore, an independent, skeptical "evaluator" agent must be introduced to find faults.

Persistency: The AI's memory shouldn't be limited to the context window that can be cleared at any time. Its state and progress must be solidified to the disk so that it can continue working the next day.

Scheduling: Use automated scripts to make the system run autonomously and periodically, closing the entire loop.

Among these, verification is the most difficult and most likely to be skipped due to laziness.

If you let the AI grade itself, it will almost always praise itself because it has a self - persuasion chain in its "mind". The solution is to introduce an independent evaluation agent that assumes the code is bad by default.

However, just because the system runs fully automatically doesn't mean you can relax. The author warns that when the loop runs wild at night, four hidden costs may quietly accumulate.

Verification debt: Minor, unverified errors are quietly merged into the repository.

Comprehension decay: The AI writes code so fast that humans' understanding of the codebase seriously lags behind.

Cognitive surrender: Humans are too lazy to review and simply accept the AI's results.

Token runaway: The AI keeps retrying in an infinite loop all night, burning through the budget.

Two people building the same loop may get completely opposite results. If you bring in judgment, it will be amplified; if you bring in laziness, that will also be amplified.

In short, this report reveals a profound industry change: Loop engineering makes code generation almost free, and human judgment has become the only scarce resource!

Additionally, a 14 - step practical manual issued by Codez is also going viral across the internet, with millions of shares.

The gist of the article is as follows: Prompts are outdated. The leverage point has moved up one level - from "words written for the AI" to "designing a system that automatically feeds the AI".

This transformation can be broken down into 14 steps and 3 stages -

First, determine whether you really need a loop (is the task repetitive? Can verification be automated? Can the budget afford it?). Then, learn the five components (scheduling, isolating the working directory, skill files, external connectors, independent evaluation sub - agents). Finally, build the minimum viable loop.

The most crucial point is to separate the agent that writes the code from the agent that reviews the code. If the same model acts as both the athlete and the referee, it will always give itself a full score.

A loop without an objective verification gate is just "two optimists nodding at each other". The better the loop runs, the more likely it is for engineers to stop truly understanding the code.

The Timeline of Loop Engineering's Birth

If we were to create a timeline for loop engineering, it would be roughly as follows.

Early Foundation Stage

20