For two years, we got really good at prompt engineering. We learned chain-of-thought, few-shot examples, system prompts — all the tricks. But in June 2026, something shifted. The people building the most powerful AI tools in the world stopped prompting entirely.
They started writing loops.
The Old Way: Prompt Engineering
The prompt engineering workflow is straightforward. You craft a prompt, send it to the AI, read the output, and repeat. Every single turn requires your input. You are the bottleneck.
This has three fundamental problems:
- One-shot with no self-correction — the AI doesn't look at its own work and say "that's wrong, let me try again."
- Human bottleneck every turn — you're in the middle of every interaction.
- Output quality equals prompt quality — if you write a bad prompt, you get bad output. There's a ceiling, and we've hit it.
The New Way: Loop Engineering
Loop engineering flips the entire model. Instead of prompting the AI every turn, you design a loop — a cycle where the AI plans what to do, executes it, evaluates its own output, and refines its approach. Then it goes around again until the job is done.
The key insight: the AI prompts itself. You design the loop, set the goal, and let the system iterate.
Think about how Claude Code works. You say "fix this bug" and it loops — reads the code, tries a fix, runs the tests, sees the failure, adjusts, and tries again. That loop IS the intelligence, not the prompt.
June 2026: The Moment It Clicked
This whole thing exploded in the first two weeks of June 2026.
Boris Cherny, the head of Claude Code at Anthropic, said it plainly: he doesn't prompt Claude anymore. His job is to write loops. He has agents that read his GitHub, Slack, and Twitter, and they decide what to build next.
Then Peter Steinberger, creator of OpenClaw, posted twelve words that got over 6.5 million views on X in under 24 hours: stop prompting your coding agents and start designing loops that prompt your agents.
Addy Osmani from Google published the essay that gave it a name — Loop Engineering. That's when everyone realized this isn't just a tip. It's a paradigm shift.
Boris Cherny's 3-Stage Evolution
Boris described his own journey in three stages — and this maps to where most developers are right now.
The receipts: in December 2025, 100% of Boris's contributions to Claude Code were written by Claude Code. 259 pull requests in 30 days. He deleted his IDE in November 2025 and hasn't opened it since.
The 5 Building Blocks of a Loop
Addy Osmani mapped out five building blocks, and both Claude Code and OpenAI Codex have converged on almost identical primitives:
- Goal — The stopping condition. "All tests pass and lint is clean." The loop runs until that's verified true.
- Scheduler — How the loop fires. A cron job, a
/loopcommand with an interval, GitHub Actions, or a manual trigger. - Verifier — A separate model checks whether the goal is met. The agent that wrote the code does not grade its own homework.
- Memory —
CLAUDE.mdpersists learnings across sessions. When an agent makes a mistake, the correction goes into memory so every future session knows about it. - Isolation — Git worktrees for parallel sub-agents. Without isolation, multiple agents editing the same files cause merge disasters.
A Real Loop in Action
Here's Boris Cherny's own example. One command into Claude Code:
/loop babysit all my PRs. Auto-fix build issues.
When comments come in, use a worktree agent to fix them.That's the entire instruction. The loop then runs autonomously:
You didn't debug the failing test. You didn't review the fix. You wrote the intent and the stopping behavior, and the loop handled everything else. While you sleep. While you're in meetings. While you're thinking about what to build next.
Prompt Engineering vs Loop Engineering
| Prompt Engineering | Loop Engineering |
|---|---|
| Single-shot interaction | Iterative self-correction |
| Human in every turn | Human sets goal, AI executes |
| Quality = prompt quality | Quality = loop design |
| One agent, one task | Multi-agent, parallel work |
| Manual context loading | CLAUDE.md persists memory |
| You watch the output | Verifier model watches output |
The Cost Reality
Loop engineering is powerful, but token costs compound faster than almost anyone expects.
The critical warning: an unattended loop without a verifier is a money furnace. If the loop can't tell when it's done, it just keeps running and burning tokens. Always set budget guards. Always have a verifier. Always have a clear stopping condition.
How to Start Loop Engineering Today
Four concrete steps you can take right now:
- Write a CLAUDE.md — Document your project context, coding patterns, and rules. This becomes your loop's persistent memory.
- Use /goal — Set a verifiable stopping condition. "All tests pass" is a good goal. "Make it better" is a terrible goal because the verifier can't check it.
- Start small — Begin with
/loopon a single PR. Watch how it works. Build confidence. Understand the token economics. - Add verifiers — Never let an agent grade its own work. Use a separate, often smaller and faster model specifically for checking whether the goal condition is met.
Final Thoughts
The leverage point has moved. It's no longer about crafting the perfect prompt. It's about designing the loop that does the prompting for you.
Boris Cherny isn't saying engineers are obsolete. He's saying the opposite — great engineers matter more than ever. Someone still has to decide what to build, talk to customers, coordinate teams. But the execution? That's what loops are for.
The job didn't vanish. It moved up an altitude. From writing the code to writing the thing that writes the code.
Stop prompting. Start designing loops.
If this was useful, check out the companion post on Context Engineering — it covers what the AI sees while the loop runs.