Stop Prompting. Start Looping: The Agentic Loop Revolution in AI Development

The way we interact with AI coding tools is changing. Fast.

Peter Steinberger put it bluntly on X: “Here is your monthly reminder that you shouldn’t be prompting coding agents anymore. You should be designing loops that prompt your agents.”

Boris Turning from the Claude Code team went further: “I don’t prompt Claude anymore. I have loops that are running. They’re the ones that are prompting Claude and figuring out what to do. My job is to write loops.” (source)

A new discipline is emerging: loop engineering. And if you are still manually prompting your coding agent, pasting output, squinting at it, and typing the next instruction, you are the bottleneck.

Let us break down what agentic loops are, when to use them, when not to, and what the best practitioners are doing right now.

What Is an Agentic Loop?

Traditionally, you are the middleman. You prompt the AI. It generates something. You read it. You decide what to do next. You prompt again. Repeat.

An agentic loop removes you from that cycle. The AI prompts itself, evaluates its own output, decides whether it is good enough, and either continues or feeds back to improve.

Think of it as the difference between telling someone “write this function” and telling them “write this function, test it, fix any bugs, and do not come back until all tests pass.” The second instruction is a loop. The agent keeps going until a condition is met.

The Loop Engineering Mindset

The Prompt Engineering channel explains it clearly. Three steps make an effective loop:

1. Define the verifier. This is the most critical part. What does “done” look like? Is it passing tests? Is it a second AI model reviewing the output? Is it a linter with zero warnings? Without a clear pass/fail condition, your loop runs forever producing garbage.

2. Design the feedback. When the verifier says no, what information goes back to the agent? The richer the feedback, the faster the loop converges. Vague feedback like “try again” produces vague results.

3. Set a max iteration cap. Loops without bounds are money bonfires. Always cap iterations. If the agent cannot get it right in 5 tries, the spec or the verifier is the problem.

The key insight: you are no longer writing code. You are writing the rules of the game the AI plays with itself.

When NOT to Use Loops (This Matters More Than You Think)

Professor Ras Mic, speaking on Greg Isenberg’s podcast, dropped a counterintuitive take: for most developers, agentic loops are “a terrible mistake unless you have money to burn.”

Why? Because loops amplify. If your prompt is bad, the loop runs bad prompts faster. If your verifier is weak, the loop churns confidently toward wrong answers. If your task is simple, the loop overhead exceeds the time you would spend just doing it yourself.

The rule: use loops when the task is repetitive, the success criteria are measurable, and the cost of iteration is lower than the cost of your attention.

Johnny Nel captured what happens when you ignore this rule. His agent ran unsupervised for 40 minutes and produced what he calls a “Ralph Wiggum Loop”:

Code review is a perfect use case. You already have a verifier: does the code pass tests? Does it match the spec? Let the agent loop on its own pull request until it is ready for human eyes.

A simple one-shot feature? Just prompt it directly.

The Zen van Riel Workflow: Four Parallel Loops

Zen van Riel, an agentic engineer with real production experience, shared his daily workflow. His setup is strikingly practical.

He launches four parallel Claude Code windows with a single keyboard shortcut. Not 50. Not one. Four.

“My mental capacity is pretty much at four parallel work streams,” he explains. “This is just what I’ve discovered after working with production users and full accountability.”

Each window runs independently on different tasks. He uses Git worktrees to isolate each stream. One window might be building a feature while another reviews it. A third handles documentation. A fourth runs experiments.

He does not chase spec-driven development or BMAD methodologies. He runs Claude Code with bash tools and MCP servers, keeps context windows from drifting, and reviews everything before merging.

The mindset shift: you stop being a writer and become a reviewer. The AI writes. You inspect. Your value moves from generation to judgment.

OpenClaw and the Architecture of Agentic Loops

IBM Technology’s breakdown of OpenClaw reveals the underlying architecture. An AI agent like OpenClaw combines:

• A large language model that reasons about tasks
• Tools the model can call: calendars, email, Slack, WhatsApp, file systems
• An agentic loop that keeps the agent running until the task completes

The loop works like this: a task arrives from Slack or WhatsApp. The agent reasons about what to do. It calls tools to act, not just suggest. It checks results. If incomplete, it loops again with new context.

This is the jump from knowing to doing. A chatbot tells you how to schedule a meeting. An agent schedules it.

The security implications are real — IBM dedicates significant time to enterprise readiness, access controls, and audit trails. Letting an LLM call your calendar API requires guardrails.

Karpathy’s 3-Layer Method: The Original Loop

Before “agentic loop” was a buzzword, Andrej Karpathy described the same pattern in his 3-layer development method:

1. Layer 1 — The Spec: Write a detailed specification. This is your verifier. The spec defines what “correct” means.
2. Layer 2 — The Verifier: A second model, or a test suite, or a linter, that checks the output against the spec.
3. Layer 3 — The Foundation: The coding agent that generates, receives feedback, and iterates.

Karpathy’s method works because it recognises that AI without verification produces confident nonsense. The spec and verifier create the loop. The agent just runs inside it.

This is the approach we teach in our AI-Assisted Development course at InitD Training. Most people prompt AI wrong. They fire off one-liners and accept whatever comes back. The professionals build loops.

Where We Go From Here

Agentic loops are not hype. They are the logical next step after we accepted that AI can write code. If AI writes code and you review it, the next step is for AI to review its own code and only show you the final result.

The skill to develop now is not prompting. It is loop design: defining verifiers, crafting feedback, setting bounds. The people who master this will build 10× faster. The people who do not will keep copy-pasting into chat windows.

The practitioners who are furthest along have already assembled the full toolkit. Demi Halford listed what the top 1% are running today:

At InitD Training, our courses teach this exact shift — from manual prompting to autonomous, verifier-driven AI workflows. Whether you are using Claude Code, GitHub Copilot, Cursor, or OpenClaw, the pattern is the same: stop prompting. Start looping.

Ready to build agentic loops? Explore our courses at training.initd.sg.

Sources

1. Why Everyone is Talking About Agentic Loops? — Prompt Engineering (YouTube, 14 Jun 2026)
2. WTF Is an AI Agent Loop? Genius or Hype? — Greg Isenberg ft. Prof Ras Mic (YouTube, 14 Jun 2026)
3. The Agentic Engineer Workflow You Need In 2026 — Zen van Riel (YouTube, 14 Jun 2026)
4. What is OpenClaw? Inside AI Agents, LLMs and the Agentic Loop — IBM Technology (YouTube, 14 Jun 2026)
5. Stop Prompting Claude. Use Karpathy’s Method Instead. — Prompt Engineering (YouTube, 10 Jun 2026)