If you've been following AI coding tools this month, you've seen the quote everywhere:
"I don't prompt Claude anymore. I have loops running that prompt Claude. My job is to write loops." — Boris Cherny, Head of Claude Code at Anthropic
This isn't just a catchy soundbite. It represents a fundamental shift in how developers interact with AI coding agents — and it has massive cost implications that almost nobody is talking about.
The Evolution Nobody Asked For (But Everyone Needed)
The progression looks like this:
- Prompt engineering (2023): Craft the perfect prompt, get one good output
- Context engineering (2024): Get the right information to the model
- Harness engineering (2025): Design the environment a single agent runs in
- Loop engineering (2026): Design systems that spawn, monitor, and verify autonomous agent work
Each step shifted leverage away from "writing better prompts" toward "designing better systems." Loop engineering is the logical endpoint: the human stops being in the loop entirely and starts designing the loop itself.
Why This Happened
Here's the architectural constraint that drives everything: LLMs are stateless. They forget everything between sessions. Every piece of context — project rules, prior decisions, intermediate results — must live outside the model.
When you prompt one turn at a time, you are the memory system. You hold the context in your head and feed it back each turn. That works for small tasks. For anything multi-step, it collapses under its own overhead.
Loop engineering is the systems design response: instead of holding context manually, you build a small system that:
- Holds context externally (files, git, memory docs)
- Decides what to prompt next
- Dispatches the agent
- Checks whether the work is done
- Loops until complete
The Cost Problem Nobody Warns You About
Here's where it gets dangerous: token costs in autonomous loops compound exponentially.
A single manual Claude Code session might cost $0.50-2.00. An autonomous loop doing the same work might make 10-50x more API calls because it's:
- Reading files to understand context (every loop iteration)
- Making exploratory changes and reverting
- Running tests and interpreting failures
- Retrying with different approaches
Without guardrails, a loop that runs overnight can burn through $200+ on what should have been a $5 task.
Three Guardrails Every Loop Needs
1. Budget Guards (Non-Negotiable)
Set a hard dollar cap per loop execution. Not per session — per task. If your agent is implementing a feature, cap it at $10. If it's fixing a typo, cap it at $0.50. The cap should reflect the value of the task, not the model's appetite.
2. A Separate Verifier Model
This is the insight most people miss: use a cheap model to verify the expensive model's work.
Your implementation loop runs on Opus or o3 (the expensive frontier model). But the verifier — the model that checks "did the tests pass? does the code compile? does this match the spec?" — can run on Haiku or GPT-4o-mini at 1/20th the cost.
The verifier runs after every iteration and decides: continue, retry with different approach, or stop and escalate to a human.
3. Task-Level Model Routing
This is the biggest cost lever available, and it's orthogonal to loop engineering itself.
Not every step in a loop needs a frontier model. The pattern that works:
- Architecture/Planning → Frontier (Opus, o3) — needs deep reasoning
- Implementation → Mid-tier (Sonnet, GPT-4o) — good enough for code generation
- Test writing → Fast/Cheap (Haiku, Flash) — boilerplate-heavy, pattern matching
- File reading/grep → No model needed — tool calls only
In practice, ~80% of coding tasks don't need frontier-tier reasoning. Routing those to mid-tier models cuts your loop costs by 60-70% without meaningful quality loss on the work that matters.
What This Looks Like in Practice
If you're using a coding agent today, here's the minimum viable loop:
1. Agent reads task description + project context
2. Agent plans approach (frontier model)
3. Agent implements (mid-tier model, budget-capped)
4. Verifier checks (cheap model): tests pass? Linter clean?
5. If no → loop back to 3 with error context
6. If yes → commit and report
The human's job is designing steps 1-6 and setting the budget caps. The models handle everything inside the loop.
The Bottom Line
Loop engineering isn't just a new buzzword — it's a genuine paradigm shift in how we use AI coding tools. But it comes with a cost trap that can 10x your bill if you're not careful.
The developers who'll win are the ones who combine autonomous loops with intelligent routing and verification. Let the system work while you sleep, but make sure it's working efficiently.
The game isn't better prompts anymore. It's better systems.
I cut my team's AI coding bill from $10K/mo to under $3K by implementing task-level model routing. The approach described in this article is exactly how we did it. If you're interested in routing, check out coderouter.io.
Top comments (1)
The loop framing lands and the externalized-context point is right. One distinction worth keeping sharp: the "separate verifier model" only works as a second view when the verifier is genuinely disjoint from the implementer. A cheap LLM checking an expensive LLM is still the same probability distribution wearing a smaller coat — they share too much training data to disagree reliably on whatever the expensive one got confidently wrong. The real second view in your list is "tests pass, linter clean" — deterministic checks that don't depend on a model being in a good mood. Worth promoting that one explicitly; it's the only verifier in the stack that can catch the implementer's blind spot.