Momentum Is Not Progress

Agent loops are not magic. They are amplifiers.

That is the part the current AI leadership class keeps trying to skip. They found the loop, wrote a few science projects, named one thing an orchestrator and another thing an agent, then decided direct prompting was obsolete. It was a great experiment to run. The advice even sounds mature until it touches a real codebase.

Stop doing direct prompting, they say. Build closed loop systems where agents plan, code, test, reflect, and self correct. Let the machine iterate. Let it recover. Let it improve its own work until the repo walks out of the fire wearing sunglasses. Mix in the Karpathy research loop. Sprinkle some goals and loops over the top. Wait for self healing software to arrive.

Reality is uglier.

This is more distraction from the actual API layer. The frontier model vendors keep wrapping the same core interaction in harnesses, tools, memory, reflection, and orchestration, then pretending the wrapper is the breakthrough. Fill the harness with bad instructions and you still get bad output. Only now it arrives with tool calls, retries, token bloat, and a dashboard that makes the waste look deliberate.

A Bad Prompt in a Loop Is Still a Bad Prompt

A bad prompt inside a loop does not become a better system. It becomes the same misunderstanding repeated with more confidence. The agent plans against the wrong objective, writes code for the wrong interpretation, reviews its own output against weak criteria, then ships a patch that still misses the point. Only now you have latency, token spend, and a long transcript that feels productive if you do not read it too closely.

That is automated drift.

Here’s your monthly reminder that you shouldn’t be prompting coding agents anymore. You should be designing loops that prompt your agents.

// @steipete, paraphrased from the genre

The bigger failure is architectural. If your codebase is already full of bad patterns, weak boundaries, naming chaos, dead tests, and years of just get it working decisions, the loop will not cleanse it. It will expand it. The agent reads the existing mess as precedent. It treats the nearest bad pattern as local law. One sloppy service becomes three. One workaround becomes policy. One leaking abstraction gets cloned across the repo like it passed an interview. The god classes. AI loves a god class. SOLID, DRY, all of it gets bypassed early unless you ram its face into the codebase.

Bad architecture becomes training data inside your own codebase.

You Used to Catch This

That does not self improve when you take yourself out of the loop. Your instincts used to catch this. Years in the industry trained you to smell the drift. You would see the shape of the mistake, pause, push back, ask someone sharper, whiteboard the problem, or stop the change before it hardened into the system.

Now people are outsourcing that judgment to an agent and calling the context history progress.

It is the old offshore circus with new clowns. Throw a vague brief over the wall. Say go. Come back months later and discover the codebase is larger, the bill is larger, the surface area is larger, and the actual value has barely moved. Lines of code increased. Understanding did not.

Progress Has a Smaller Definition

The compiler error is gone. The runtime path is verified. The diff is smaller, safer, and closer to the spec. That is progress. Everything else is activity wearing its lanyard.

Watch where the fakery hides. The tests pass, but most of the time nobody tested the failure cases. The screenshot matches the subjective AI state, except AI cannot see images properly anyway. It feels like you are measuring progress. You are actually just watching the machine stay busy.

Loops work when the foundation is worth iterating on. Clear boundaries. Consistent patterns. Real tests. Strong names. Small modules. Written rules for how the system is allowed to change. At that point, iteration is not the agent magically improving code. It is the agent being forced to stay inside the containment lines. You are not designing a self iterating loop. You are trying to outsmart and contain a wild animal.

This is why coding agents can look impressive and generic reflection agents often look like a meeting with no agenda. Code has external signal. A compiler says no. A unit test says no. A linter says no. A runtime log says you broke the path at line 47. The loop only becomes real when something outside the model can reject the model on a deterministic hard failure.

Without that, reflection is just self commentary and a subjective circle of agreement.

The Boring Hierarchy

The order should be unglamorous. Prompt mastery first. Tool use second. Minimal loops third. Complex multi agent systems last, and only when the problem earns the cost.

The best loops still start with a strong direct prompt. The goal is named. The files are named. The constraints are named. The acceptance criteria are named. The verification path is named. The loop does not replace clarity. It punishes the lack of it.

So no, just build better agent loops is not good advice. Be a part of the loop. That is the version that lands.

Build better foundations. Write better prompts. Add tools. Add verification. Then add the smallest loop that closes around real signal. Otherwise you are not building an intelligent system. You are giving architectural drift a bigger engine.

AI will always do the task at half measure. It never does the task 100%, and when you feel like it has, you realise it is lying. That has never changed. It is always holding back. You blame the AI for that, but the real reason is that you stopped pushing the drift back inwards. You stopped shaping the pathways as it expanded.

Just like you would have done had AI never been in the mix.