By Monique Bozeman Published June 25, 2026 | 7 min read

In June 2026, Boris Cherny — the head of Claude Code at Anthropic — said something that reframed how a lot of developers think about AI tools:

“I don’t prompt Claude anymore. I have loops running that prompt Claude and figuring out what to do. My job is to write loops.”

Almost simultaneously, OpenAI engineer Peter Steinberger wrote that developers “shouldn’t be prompting coding agents anymore” — they should be “designing loops that prompt their agents.” Google engineer Addy Osmani then published a widely shared essay that gave the pattern a name: loop engineering.
This isn’t hype. It’s the practical next step in how AI gets used for real work. Let me walk you through the full evolution — and what it means if you’re building or running a business with AI.

The Old Habit: You Were the One in the Loop
Remember when using AI meant constant back-and-forth? Like yesterday? You’d craft a prompt, scan the output, adjust based on what came back, and repeat. You were the memory bank, the judge, and the strategist. For quick tasks, fine. For anything sustained — ongoing research, code fixes, business operations — it burned time and left room for mistakes.

That manual cycle is what builders are leaving behind.

Agentic AI: Giving Models Real Agency
Agentic setups let the AI plan its own steps, grab tools, reason through problems, and continue until it hits a goal. Think ReAct-style loops or multi-agent frameworks. They’re strong for open-ended problems where you can’t map every turn in advance.
The upside: Flexibility. They can pivot based on what they discover mid-task.
The problem: Without additional structure, they forget between runs, hallucinate under pressure, and lack reliable guardrails. A single agent trying to do everything often goes off the rails or wastes resources. Powerful explorers — not always production-ready on their own.

Workflows: Solid Structure for Repeatable Work
On the other end, you have workflows — n8n, Zapier, graph-based automations in LangChain. These define clear steps, branches, and integrations. Predictable, auditable, great for processes you run repeatedly (lead generation, data pulls, simple automations).
The upside: Reliability and visibility. You know exactly how things flow.
The problem: Rigidity. When reality throws a curveball or the task requires creative problem-solving, predefined paths break or require constant manual updates.

Loop Engineering: The Layer That Ties It Together
This is where it gets interesting. Loop engineering means building a system that orchestrates agents in ongoing cycles. Side note: Can we really, actually catch up to the years of contact center marketing hype buried in that word orchestration? You design the framework once — triggers, memory, checks — and it handles prompting the models, verifying results, updating knowledge, and deciding what comes next.
The human steps back from micromanagement to architecture.

The core components of a well-built loop:

Triggers — Cron schedules, webhooks, or commands like /schedule that fire the system on schedule or on events
Persistent state — Files (like CLAUDE.md in Claude Code) that capture rules, past lessons, and best practices so the system doesn’t start from scratch every run
Independent verifier — A separate agent or model that checks the work the main agent produced; the maker-checker principle. One agent should never grade its own homework.
Isolation — Separate working environments (git worktrees, for example) for parallel work without conflicts
Real-world connectors — MCP integrations that let the loop actually do things: open PRs, update tickets, post to Slack, query databases

These aren’t magical. They’re borrowed from how serious engineering operations already work, supercharged with AI.

How the Approaches Compare

Approach	Best For	Memory	Verification	Human Effort
Basic Prompting	Quick one-offs	None	You	Constant
Agentic AI	Exploration & planning	Session only	Weak / self	High oversight
Workflows	Repeatable processes	Config-based	Rules-based	Setup + monitoring
Loop Engineering	Ongoing, self-improving tasks	Full + updating	Dedicated agent	Design once, review outputs

What This Looks Like in Practice
Anthropic is the clearest real-world case. By May 2026, Claude was authoring over 80% of their merged production code. Engineers reported shipping eight times more code per day than in 2024 — not because they got smarter, but because the system they built amplifies their judgment rather than replacing it.
Cherny himself described running thousands of overnight sub-agents for complex tasks, with worktrees keeping parallel work isolated and verifiers catching errors before they propagate.
The same pattern appears in operations at companies like Klarna and Shopify, where agents handle customer issue resolution end-to-end with escalation logic — and in financial firms where data pulls, signal generation, verification, and execution run in self-updating cycles.

How to Start
Pick something annoying you do every week. Then:
1. Start with state tracking and a basic verifier before going fully autonomous
2. Define hard stop conditions you can check externally — not “until the AI says it’s done”
3. Keep logs readable — you’ll need them when something breaks
4. Review early runs closely — build trust in the system before extending its autonomy
5. Scope tightly — token costs compound fast in agentic loops

The goal isn’t to replace your judgment. It’s to build a system that applies your judgment at scale, while you focus on what actually requires you. I’m playing around with this for small business, one person shops to see what I can create. I’l let you know how it goes.

The Takeaway
Prompting showed us how to talk to AI. Agents brought goal-directed action. Workflows brought order. Loop engineering lets the system run responsibly — compounding what it knows with every cycle.
For anyone running a business or building products with AI, this is where the real leverage is right now. Not in better prompts. In better systems.
The builders pulling ahead are the ones designing loops today.

Sharing this for my colleagues in contact center software — the loop engineering pattern maps directly onto problems we’re already solving: persistent knowledge bases, QA verification agents, workflow automation that actually adapts. The question worth asking: are we building platforms that enable loops, or platforms that will be replaced by them? Loop engineering is coming to our space whether we build it or someone else does.

Sources: Anthropic “When AI Builds Itself” report (June 4, 2026); Boris Cherny public statements (CNBC, Sequoia AI Ascent, June 2026); Addy Osmani, “Loop Engineering” (June 2026); Peter Steinberger on X (June 7, 2026); The New Stack, TechTimes, VentureBeat coverage (June 2026).