There is a new flex in AI right now. You do not write prompts anymore. You build loops.
Scroll your X feed or LinkedIn feed and you will see it. The Startup Ideas Podcast ran a whole episode on whether agentic loops are the future of building or an expensive trap. Tim Hughes is telling his audience that agent loops are AI’s next big shift, citing the creator of Claude Code and the founder of OpenClaw. Lenny Rachitsky’s newsletter published a tutorial on writing agent loops in Claude Code and Codex. MindStudio is calling loop engineering “the new meta for AI coding agents.”
The hype is loud.
The hype is fifty years late.
The loop is the easy part. It was always the easy part. A fighter pilot named John Boyd solved the hard part half a century ago, from a cockpit, with no model and no token budget. The crowd selling you “loop engineering” as the new meta is charging admission to a lesson that has been sitting in the open since before most of them shipped a line of code, and in plenty of cases before they were born.
One disclosure. I am as old as the idea these people are reselling, born the year after Boyd first gave the briefing. So yes, this one is a little personal.
Boyd Already Solved This
The OODA loop comes from John Boyd, a military strategist and fighter pilot. Observe, Orient, Decide, Act. Most people who cite it treat it as a cute four-step cycle: take in information, make sense of it, choose, do the thing, repeat.
That is not what Boyd was saying, and the part everyone skips is the part that matters.
Boyd’s first claim was that Orient dominates. Observe, Decide, and Act are mostly plumbing. Orientation is the model you filter reality through: your experience, your training, your sense of what matters and what to ignore. Everything else feeds it or flows from it. Win the orientation and the other three get easy. Lose it and speed just carries you to the wrong place faster.
His second claim was about tempo. The goal of cycling fast is not speed for its own sake. The goal is to operate inside your opponent’s loop, to move fast enough that their model of the world goes stale. They end up solving yesterday’s problem while you are already on tomorrow’s.
Hold those two ideas, because they explain the entire loop conversation happening right now.
The Loop Is Recursive
Here is the part most OODA explainers get wrong. The loop is not four boxes in a circle. Every box is its own loop.
Decide is an OODA loop. Observe is an OODA loop. The structure is fractal, loops inside loops, all the way down. This matters because it explains the thing experts do that looks like magic.
The master martial artist sees the punch before it is thrown. Boyd’s pilots reacted before they consciously chose to. The standard explanation is that experts “skip” the deciding. They do not. The decision loop ran so fast that we can practically say it did not happen. Compressed to nothing, but still there.
I have studied martial arts. I am no master. But I have stood across from many. Years ago, in a demonstration on controlling the surface area of engagement, two of us were tasked with hitting an eighty-year-old grandfather, a multi-degree black belt. Two on one, and we could not lay a hand on him. He struck me twelve times in a single flurry. I know it was twelve because I counted, and he confirmed it afterward. His loop was running so far inside mine that I was still observing while he was already done.
And it is not just Decide that collapses. Observe collapses too. Malcolm Gladwell called it thin-slicing in his book “Blink.” The expert does not take in more information than the novice. They take in less, the right less, because their orientation tells them exactly where to look: the weight shift, the shoulder, the tell. The novice observes everything and drowns. The master observes one slice and knows.
So expertise is not a faster cycle. It is the whole loop compressing into orientation until, from the outside, it looks like pure instinct. Observe collapses into thin-slicing. Decide collapses into the instant choice. What is left looks like a person who just knows.
Vibes Are an OODA Loop Running Hot
This is the mechanism underneath Vibe Coding Is Not a Strategy. The job of that piece was to separate expert vibes from novice feels. Here is why they are not the same loop.
Andrej Karpathy’s vibe coding is an OODA loop run fast and loose. Run the code, see what breaks, feel what is wrong, fire the next prompt, accept the diff. The “vibe” is the Orient step compressed into gut feel. You are not building a careful model of the code. You are orienting on instinct and letting tempo carry you.
It works because the loop is fast enough that bad steps get caught before they compound. Which tells you exactly when it fails. Thin orientation plus a fast loop only survives when the feedback is tight enough to catch its own errors. At low stakes, this works well. When it comes to load-bearing production code, if the loop cannot see its own mistakes, the vibes turn into vibe shipping.
Gladwell was honest about this, and it is why “Blink” is the right reference and not a flattering one. Thin-slicing misfires when the orientation behind it is wrong. The snap judgment that is confident and incorrect. That is the exact failure mode of an AI agent: it pattern-matches fast, it hallucinates a pattern that is not there, and it is completely sure of itself. Fast. Instant. And wrong. The fix is never slower observation. The fix is better orientation.
Watch What the Hype Keeps Backing Into
Now go back to the loop discourse with Boyd in hand. Read what the loudest voices actually conclude once they get past the headline.
The MindStudio piece defines a loop as: take an action, observe the result, decide the next move, repeat until the goal is met. That is OODA, beat for beat, with the serial numbers filed off. Then they spend the rest of the article on what makes a loop good, and every item is an orientation problem. A clear goal with testable termination. Structured feedback instead of raw output. Knowing when the task is too big. Their own conclusion is that the quality difference between agents is not the model, it is the loop design.
The Startup Ideas episode goes further and lands the cleanest version of the insight. Their verdict is that open build-loops are a money fire for almost anyone building a real app, and there is exactly one loop worth copying: code review. Why does that one work when app-building loops drift? Their answer is the feedback signal. Code review has a fixed, binary target. The code passed or it did not. Building an app does not, because you cannot fully picture the thing yet, so you cannot hand the agent a clean target to chase. A loop converges when the target is crisp. A loop drifts when the target is fuzzy.
Read that again. A loop converges when orientation is good and drifts when orientation is thin. That is Boyd. They rediscovered it by burning tokens.
And a drifting loop does not fail quietly. It churns out plausible, structureless, contradictory code faster than you can read it. That is not the model writing spaghetti. That is you, handing a relentless junior developer a fuzzy target and walking away. AI Doesn’t Write Spaghetti Code. You Do. A loop does not fix that problem. It industrializes it, speeds it up, and burns tokens in proportion to the scale of the loop.
The pattern repeats everywhere once you see it. Lenny’s tutorial warns that fuzzy success criteria make the agent loop forever, and tells you to think about a loop the way you think about onboarding an employee: define the job, the checks, the output, who to call when something breaks. The best comment on that post says the real breakthrough is not autonomy, it is supervision: the goals, the scoring, the verification, and the human review path that keep the whole thing from becoming fast nonsense. Tim Hughes describes a loop as handing an agent a goal with clear instructions and success benchmarks. The Firefox security team in that same newsletter shipped hundreds of fixes, and credited the harness, not the model: an LLM that scores files by risk, a verification loop that kills false positives, humans kept in review.
Goals. Success benchmarks. Scoring. Verification. Defining the job. Every single one of them is Orient. Nobody is actually excited about the loop. They are excited about the orientation they had to build to make the loop converge, and they are calling it “the loop” because that is the word that is trending.
The Killer App Is the Orientation Layer
So here is the bet worth making. The durable work in agentic AI, the real killer app, is not faster loops or more loops or loops that spawn loops. It is the orientation layer that lets a loop decide quickly and well.
Concretely, that is two things.
Decision context is what the agent knows and how it is framed. This is the Orient feed. It is the standards, the architecture notes, the conventions, the map of which files actually matter. I publish a reference implementation of exactly this. Every module under the standards directory is decision context for a particular kind of decision, indexed by a router so the agent loads the right slice for the task in front of it and nothing else. I covered the cross-team version in Cross-Team Agentic Coding Standards. Good decision context does not just speed up the choice. It tells the agent where to look, so Observe collapses too. An agent that reads everything is the drowning novice. An agent that reads the right slice is the master.
Decision mechanisms are how a decision gets committed, executed, and checked. Tests are a decision mechanism. They let the loop answer “is this right” cheaply, so it can decide and move. A code-review score with a hard floor is a decision mechanism. A branch rule, a deployment gate, a verifier subagent: all decision mechanisms. They are what let the inner Decide loop collapse instead of spinning.
Notice which parts of the loop the whole industry already ships for free. Tool use, code execution, file editing, retrieval: every agent framework has them, and they get cheaper every quarter. That is Observe and Act. Raw Decide horsepower is a price war between labs. The part nobody can hand you is Orient, and the proof is in this very article. Every source above reached the same conclusion: the differentiator was the goal, the criteria, the scoring, the harness. Never the model.
The fair objection is that orientation tooling is commoditizing too. Vector stores, memory layers, standards templates, goal-writing guides: all off the shelf now. True, and beside the point, because the tooling is not the orientation. The standards that encode your judgment, the success criteria that fit your product, the definition of done your domain demands: those are authored, not purchased. Generic orientation produces generic software nobody asked for. The plumbing commoditizes. The content never will. That is where the moat is, and that is where your engineering effort belongs.
This is also why stories did not die when agents learned to code. A well-crafted story is orientation delivered at the unit of work. It carries the what, the why, the edge cases, and the definition of done: the exact frame an agent needs to converge instead of guess. Better stories produce better output, and not because the model got smarter. Because the input did. That is the whole argument of Your AI Can Write Code. It Still Needs Stories. A story is decision context scoped to one piece of work, which is to say a story is orientation.
Why Vibe Coding Does Not Scale, In One Sentence
Vibe coding works because the human is the orientation layer.
Karpathy orienting on instinct, judging the diff, feeling the wrong turn: that is a world-class Orient step sitting in the loop. The reason it does not scale is that the human is the bottleneck, hand-carrying orientation into every cycle. The Startup Ideas crew closed their episode with the line that “human in the loop is the best loop,” and on a $20 plan today they are right.
But that is the ceiling, not the destination. The job is to move orientation out of the human’s head and into the system, so the loop can orient and decide without waiting on a person standing in the middle of it. Not abdication, which is vibe shipping. Externalization. The standards written down. The context loaded. The verification real. Judgment carried inside the system instead of applied by hand.
That is the same argument I have been making about intent, standards, and ownership, viewed one level deeper. The mechanism under all of it is orientation.
The Takeaway
Stop optimizing the loop. The loop is a prompt that fires itself. It is the easy part, and treating it as the breakthrough is how teams end up with fast nonsense.
Optimize orientation. Write the success criteria so sharp the loop has a real target. Build the decision context so the agent looks in the right place. Build the decision mechanisms so a decision can be checked and committed without you. Do that, and the loop converges, the inner cycles collapse, and the whole thing starts to look like the expert who just knows.
Boyd handed us the answer fifty years ago, from a cockpit, before personal computers existed, while the disciplines now selling “loops” had not been invented. Orientation wins. The people shouting “loops” are about to pay full price to relearn it, one burned token at a time.
Receipts
- Boyd, 1976. The OODA loop comes from John Boyd’s Patterns of Conflict, first presented in 1976. His central claim was never the four-step cycle. It was that orientation dominates the other three.
- The harness, not the model. Mozilla’s Firefox team shipped hundreds of security fixes by wrapping the agent in a harness: an LLM that scores files by risk, a verification loop that kills false positives, and humans kept in review. They credited the harness over the model, on Lenny Rachitsky’s “How I AI.”
- Convergence needs a clean target. The Startup Ideas Podcast found open build-loops drift and burn budget, while a code-review loop converges, for one reason: code review has a fixed, binary success signal and app-building does not. Their verdict, “human in the loop is the best loop,” is an orientation argument.
- Fuzzy criteria, infinite loop. The “How I AI” loop tutorial warns that vague success criteria make an agent loop forever, and frames a good loop as a job description: define the work, the checks, and what done looks like.
- The crowd keeps naming orientation. Across all four loop sources cited here, the differentiator was the goal, the criteria, the scoring, or the harness. Never the base model. The loudest voices in the loop discourse are excited about orientation and calling it “loops.”
- Twelve hits. In a martial arts demonstration on controlling the surface area of engagement, an eighty-year-old black belt landed twelve strikes on me in a single flurry while two of us failed to touch him. I counted, and he confirmed the number afterward. That is what operating inside another loop looks like.