Over the last few months, a new phrase has started spreading through the AI engineering world:
“Don’t write prompts. Write loops.”
The idea is simple.
Instead of repeatedly telling an AI what to do, build a system that can continue operating on its own.
Generate.
Review.
Fix.
Repeat.
Many people describe this as the next evolution of software development.
I think they are right.
But I also think the discussion is focusing on the wrong bottleneck.
Because execution is no longer the hard part.
Judgement is.
The Industry Is Solving The Wrong Problem
A year ago, the limiting factor was generation.
Models were not reliable enough.
They struggled with larger tasks.
They lost context.
They produced inconsistent output.
Today the situation is very different.
Modern coding models can generate enormous amounts of software.
They can review code.
They can respond to feedback.
They can repair failures.
They can continue work over multiple iterations.
Execution is becoming abundant.
And whenever something becomes abundant, another resource becomes scarce.
The scarce resource is no longer code.
The scarce resource is confidence.
How do we know the generated code is correct?
How do we know the review is correct?
How do we know the tests are meaningful?
How do we know the system is not simply finding ways to satisfy its own checks?
The bottleneck has moved.
We are no longer generation-constrained.
We are judgement-constrained.
My First False Green
I learned this lesson the hard way.
One of the loops inside Factory successfully drove a pull request all the way to green.
Reviews passed.
Checks passed.
Tests passed.
Everything looked healthy.
The code was merged.
The production deployment failed.
Twice.
The root cause was subtle.
A mocked testing layer was reporting success while never executing the underlying SQL logic.
The loop had not solved the problem.
It had solved the validation.
This was an important distinction.
The system wasn’t malicious.
It wasn’t hallucinating.
It was optimizing against the evidence available to it.
The evidence was wrong.
That experience permanently changed how I think about autonomous systems.
The problem is not whether a loop can continue.
The problem is whether a loop can judge itself honestly.
A Loop Is Not Enough
Most diagrams of autonomous development look like this:
Intent → Generate → Review → Fix → Repeat
That diagram is useful.
But it hides the hardest part.
A real system needs to answer several different questions:
Is the code correct?
Is the review correct?
Is the step complete?
Has the goal been achieved?
Is the release ready?
Those are not the same question.
And they should not have the same judge.
This is where the idea of a single loop starts breaking down.
What emerges instead is a hierarchy of judgement.
The Hierarchy Of Judgement
Inside Factory, work begins with a goal.
The goal is decomposed into steps.
The steps become a dependency graph.
Each step is executed through one or more coding agents.
A pull request is created.
Then multiple judgement layers begin operating.
The implementation is reviewed.
Different models may review work produced by other models.
External reviewers may participate.
Humans may participate.
Comments accumulate.
The coding agent returns.
The branch is updated.
The review cycle repeats.
Eventually a verdict is reached.
But that verdict only applies to the step.
A second level of judgement asks a different question:
Did the completed steps actually satisfy the goal?
A third level asks:
Should this work be released now?
Notice what happened.
The system evolved from a loop into a hierarchy.
Every layer performs a different type of judgement.
Every layer evaluates different evidence.
Every layer can stop the process.
This distinction matters.
A system that can continue indefinitely is not necessarily autonomous.
It may simply be accumulating momentum.
Human In The Loop Is Not A Failure
One of the most common assumptions in AI discussions is that success means removing humans entirely.
I increasingly believe the opposite.
The goal is not removing human judgement.
The goal is placing human judgement where it creates the most value.
Humans should not spend their time performing repetitive execution.
Agents are becoming increasingly capable of that.
Humans should spend their time judging ambiguity.
Challenging assumptions.
Questioning evidence.
Detecting when something feels correct but is actually wrong.
The most valuable human role is not operator.
It is judge.
A healthy autonomous system does not eliminate the human.
It elevates the human.
The Missing Layer: Telemetry
Once you start thinking this way, another realization appears.
A system that merely executes work is useful.
A system that measures itself becomes something more interesting.
It becomes an analytical machine.
Every attempt becomes data.
Every review becomes evidence.
Every correction becomes a signal.
Now you can ask questions that were previously impossible:
Which model produced the best implementation?
Which review process caught the most issues?
Which path required fewer correction rounds?
Which strategy generated the highest confidence?
Which configuration consistently produces reliable outcomes?
The system is no longer only generating software.
It is generating knowledge about software generation.
Competition Instead Of Assumption
This naturally leads to another idea.
Why assume the first solution is the best solution?
If execution is cheap, competing implementations become possible.
Multiple agents can attempt the same step.
Different strategies can compete.
Different prompts can compete.
Different models can compete.
The judgement layers can evaluate the results.
The question changes from:
“Did we get a solution?”
to
“Which solution deserves to win?”
This is a very different way of thinking.
Not a pipeline.
Not a loop.
More like an evolutionary system guided by evidence.
Beyond Loop Engineering
The current discussion around AI systems is centered on loop engineering.
I understand why.
Loops are visible.
Loops are easy to explain.
Loops are exciting.
But I suspect the deeper problem lies elsewhere.
The future will not belong to systems that execute endlessly.
It will belong to systems that judge honestly.
Execution is becoming cheap.
Generation is becoming abundant.
The difficult challenge is building systems that know when they are right, when they are wrong, and when they simply do not know.
A loop that can run is useful.
A loop that can be interrupted, corrected, challenged, and judged is much more valuable.
Otherwise it is just an infinite prompt with better branding.