Apparently, we discovered iteration in 2026.
At least that is how it feels when browsing X or LinkedIn right now. Loops are everywhere. Agent loops. Feedback loops. Self-improving loops. Loop engineering. Agents running at night. Agents improving themselves. Agents that supposedly need nothing more than a goal and then iterate until something is finished.
And yes: loops are useful. Of course they are. I constantly work in loops myself. When writing. When building. When debugging. When thinking about product decisions. The loop is not the problem.
The problem is that people are acting as though AI agents suddenly invented iteration.
A loop without judgment is just faster repetition.
That is what annoys me about this hype. A useful way of working is being turned into a new miracle. As though a loop were a perpetual motion machine. As though repetition automatically produced direction. As though putting “self-improving” in front of it turned a loop into an intelligent work system.
But that is not how work happens.
Iteration was never the new part
People have worked iteratively for as long as they have worked. Even organizations that officially described waterfall processes iterated. Not necessarily elegantly. Not necessarily explicitly. Not always with good feedback cycles. But of course they reassessed after each step.
You write a specification and realize while explaining it that a term does not hold up. You build a first screen and immediately see that the information hierarchy does not work. You implement a feature and realize during testing that the real product question lies elsewhere. You show a customer an intermediate result and hear that very particular sentence: “Yes, that is not what I meant.”
This is no modern insight from agents. It is the basic movement of any serious work.
An action changes the state. The new state changes what we know. What we now know changes the next step.
Sometimes it changes only a small detail. Sometimes it changes the path. Sometimes it even changes the shape of the goal. And sometimes an intermediate result is the first thing that reveals that the goal itself was described incorrectly.
Iteration is not a method. It is what happens when reality answers.
That is why the current loop rhetoric often falls short. It describes repetition, but not assessment. It shows the circle, but not the judgment that determines the next step.
The important part is not the loop
A loop is not simply “do that again.” A meaningful loop has at least four parts:
- act
- observe
- assess
- adapt.
The hype likes to talk about acting and repeating. An agent receives a goal. The agent produces output. The agent checks the output. The agent repairs the output. The agent keeps running. That sounds tidy. And in some cases, it is.
When the work has a clear goal and the assessment signal can be described well, an automated loop can be very powerful. Tests are a good example. So is linting. Broken links. Format checks. A JSON schema. A build that either runs or does not. A pull request that fixes a specific error message.
A machine is welcome to loop there. In fact, it should. A person does not need to handle every trivial correction manually when the goal, signal and stopping condition are clear enough.
But much work is different.
When I write a text, “better” is not simply a test result. When I assess an interface, “works” is more than a green build. When I sharpen a product idea, the new intermediate state is more than output: it is a new object of thought. I see something. I respond to it. I notice that an example feels too internal. That a term is too polished. That a feature is correct yet misses the actual question.
You cannot neatly squeeze this into a small autopilot loop.
Who assesses the new state?
The real design question is not: “Do we need a loop?”
The real question is: “Who or what assesses the state after each iteration?”
Sometimes the answer is simple:
- A test.
- A compiler.
- A type check.
- An evaluator.
- A metric.
- A schema.
- A clear comparison with a requirement.
Sometimes the answer is: a person.
Not because humans are romantically superior. Not because automation is bad. But because some decisions carry meaning. Direction. Taste. Responsibility. Context. Product sense. User perception. Everything that becomes visible in the work only once an intermediate result exists.
This is precisely where “human in the loop” is often misunderstood. Sometimes it sounds like an embarrassing leftover: a person still has to step in because automation has not advanced far enough.
I think that misses the point.
A person is more than a safety net at the end. In much work, the person is the one who can first say what a new intermediate state actually means.
The crucial design question is not whether the system runs through a loop. What matters is who judges the new state.
This applies especially to product work. A customer often does not know exactly what they want until they see what has been built. That is not a customer failure. It is normal. Perception changes requirements. A visible intermediate result makes differences real that were previously only abstract.
The same happens in writing. In design. In architecture. In strategy. In tools. In almost everything where “right” is not fully known before the work begins.
Automatic loops need boundaries
Automated loops are powerful when they have boundaries.
Automatic loops need:
- a goal.
- a signal.
- a stopping condition.
- an idea of what should not be optimized.
Otherwise, they merely generate movement.
An agent fixing an error message can sensibly run until the test passes. An agent normalizing a list against a schema can sensibly run until all entries fit. An agent finding broken links can sensibly repair them until none remain.
That is boring in the best sense. It is clear. It is useful. It saves attention.
But when an agent is told “make the article better,” things become harder.
- Better for whom?
- In what tone?
- With what risk?
- Should the text become sharper or calmer?
- Should it become more personal or better substantiated?
- Should it show more sources or fewer?
- Should it challenge a hype or put it in context?
Without this assessment, the loop does not become intelligent. It merely becomes active.
And activity is not the same as progress.
Human in the loop does not mean micromanagement
The alternative is not for the person to do every small step themselves again. That would be just as wrong.
I do not want to repair broken links by hand when an agent can do it reliably. I do not want to handle a hundred formatting errors individually. I do not want to type every boilerplate step myself. When a loop is clear enough to automate, it should be automated.
The interesting point lies in the division of work. AI can create intermediate results very quickly. This brings me sooner to the interesting point. I can see whether a structure holds up. I can assess whether an example works. I can decide whether an image really makes the thought process visible. I can notice whether a text sounds like me or like generic AI content.
That is no small difference. Previously, much attention was tied up in implementation. Today, a state I can respond to emerges sooner. But that is exactly why judgment becomes more important.
AI makes intermediate results cheaper. That makes human judgment more important, not less.
As intermediate results become cheaper, more of them appear. More variants. More possibilities. More plausible paths. More things that might somehow work. And therefore more decisions about which direction holds up.
Loops do not automatically solve this problem. They move it.
A useful loop asks about judgment
Perhaps we should discuss loops less in terms of autonomy and more in terms of work design.
Not: how do I keep the agent running for as long as possible?
But:
- What is newly known after each step?
- Which signal can be assessed automatically?
- Which decision needs human judgment?
- When does the loop end?
- What may the loop change?
- What stays with the person?
That sounds less spectacular than “100 agents running overnight.” But it is probably the more useful part.
A good loop is no magic circle. It is deliberately designed feedback. Sometimes automated. Sometimes led by a person. Often mixed.
And perhaps that is precisely the difference between hype and work.
Hype says: build loops.
Work asks: what feedback does this context need?
Conclusion
I do not think the current loop hype is completely wrong. Quite the opposite. Loops matter. Agents become more powerful through loops. Many tasks will benefit from AI doing more than answering once: checking, correcting and continuing to work.
But a loop is no perpetual motion machine. It does not generate meaning by itself. It does not replace the question of what is good. It does not replace direction. It does not replace product judgment. It does not replace the uncomfortable, necessary thinking after a new intermediate result.
Perhaps this is the sober version of it all:
- Automate the loop when judgment is described clearly enough.
- Keep the person in the loop when the new state changes meaning.
- And do not sell iteration as new magic just because it now contains an agent.