Everyone is excited about agentic loops right now. The pitch is seductive: you give the agent a goal, it works autonomously until it's done, and you walk away. The agent reasons, acts, checks its own work, and iterates from start to finish.
I'm not fully buying it.
Not because loops don't work. They do, sometimes. But there's a cost that doesn't get talked about enough: tokens, time, and control. Until those three things are essentially free, I want to stay close to what my agent is doing.
The cost of autonomy
The Loop Tax
Every iteration of an autonomous loop costs tokens. Every token costs money and latency. More importantly, a looping agent that goes in the wrong direction doesn't just waste one attempt: it compounds the mistake across several, often arriving somewhere you didn't want to go and doing so confidently.
I've learned to distinguish between tasks I can fully delegate, where I go AFK and let the agent run, and tasks where I want to watch it think. The latter is more common than people admit. Seeing the agent's intermediate steps isn't a sign that you don't trust it. It's a sign that you understand the value of review, even when you're the one doing it.
Codex has a feature called "Steer": the ability to nudge the agent mid-task without fully stopping and restarting it. I love that idea, and I wish Claude Code had something equivalent. The closest you get there is: stop the task, inject a correction, restart. It kind of works, but it's not the same. True mid-course correction, without losing context, is one of the most underrated features an agentic tool could have. Until it's standard, the best control I've found doesn't come from the tooling. It comes from the workflow.
A better approach
The Better Path: Give the Agent a Mirror
Here's what I've found works better than more looping: give the agent metrics.
Not vague instructions like "make this cleaner" or "improve the quality." Specific, measurable signals that tell the agent exactly where it fell short, before it tries to fix anything.
The insight is simple: flag the problems first, then fix them. Make the agent generate a diagnostic pass before a remediation pass. This turns an opaque loop into a transparent two-step, and it produces measurably better results.
For software teams
For Developers: Beyond Tests
In software, the standard feedback loop is unit and integration tests. Pass/fail. That's good, but it's incomplete.
Tests tell you if the code works. They don't tell you how well it's built.
Add cyclomatic complexity, cognitive complexity, coupling metrics, and duplication percentages on top of your tests. Now you have a richer signal. Feed those scores to the agent explicitly: "This function has a cyclomatic complexity of 18 and a maintainability index of 42. Refactor with those as targets."
A tool like Radon does this for Python without any inference: it computes cyclomatic complexity and maintainability scores deterministically, at no token cost. Feed those numbers to the agent and it works from a ground truth no prompt can fudge.
The agent now has a concrete definition of "better." It's not guessing at your intent. It knows whether a refactor actually improved the architecture, not just whether the tests still pass. More importantly, you can decide which tradeoffs to make. That decision stays with you, not with the loop.
For writers and content creators
For Authors: Prose-Level Diagnostics
The same logic holds outside software. I've been writing a book lately. It's outside my comfort zone, and that's the point: it gives me the perspective of someone doing "vibe coding" but for content. You have a goal, you have a collaborator, and you're trying to produce something coherent without fully knowing the rules of the craft.
The same principle applies. Instead of telling the agent "rewrite this chapter to be better," give it a diagnostic pass first.
Define your craft rules explicitly, the skills you want the writing to demonstrate, and have the agent scan the text against each one before touching a word:
- Tone consistency: does the voice drift? Where?
- Pacing: are there sections where momentum stalls?
- Repetition: what words, phrases, or ideas are overused?
- Openings and endings: do scenes and paragraphs start and end with impact?
- Flow and transitions: does the argument or narrative move logically?
- Argument integrity: are claims supported? Are there logical gaps?
Each of these becomes a measurable output: a list of flagged instances with locations. The agent produces the diagnostic, you review it, you decide what matters, and then you prompt the rewrite against those specific findings.
This is the difference between asking someone to "clean up a room" and handing them a checklist of what's actually wrong. The checklist produces better work, faster, with fewer surprises.
The pattern behind the pattern
What This Actually Is
It's not a loop. It's a structured two-pass workflow: diagnose, then fix. And the human sits between the two passes, reading the diagnosis, deciding what to act on.
Call it Measure → Review → Remediate. Three steps, clearly separated, each with a distinct purpose.
The Measure pass is cheap. It doesn't even have to come from the agent: for code, deterministic tools measure what needs measuring, leaving the agent to consume the output rather than produce it. For prose, the agent does more of the measuring since language carries ambiguity that code does not. Either way, the output is a structured list of findings: where complexity is too high, where tone drifts, where the argument has a gap. Fast, focused, and brief.
The Review step is yours. This is the part that loops try to automate, and it's the part that matters most. You read the findings. You decide which ones are real problems and which are false positives. You decide what to prioritize. You bring context the agent doesn't have: the deadline, the audience, the tradeoff you're willing to make between architectural purity and shipping speed. No autonomous loop can make those calls for you. If it tries, you'll spend more time undoing its decisions than you saved by delegating them.
This isn't a new idea
GitHub's Spec Kit bakes it in by design. Its workflow moves through four named phases (specify, plan, tasks, implement), and each phase produces artifacts that a human is expected to review before the next phase begins. That's not a bug in the design, it's the point. The gates are there on purpose. Spec Kit's authors understood that the value isn't in removing the human from the loop; it's in putting the human in the right places in the loop.
The Remediate pass is where the agent does its best work. Now it's working from a specific brief, not a vague instruction. It knows exactly what to fix and why. The output is targeted, the token cost is proportional to actual work done, and there are no surprises because you shaped the direction before it started.
That's what loops cut out: human judgment. Loops are optimized for throughput. This approach is optimized for quality and control.
The agent isn't iterating blindly, hoping to converge. It's giving you information, you're giving it direction, and it's executing with clarity. For a fraction of the tokens, you get a collaboration that outperforms any autonomous spiral.
The takeaway
The Common Thread
There's something worth naming at the prompt level. When you ask an agent to diagnose before it fixes, you're forcing it to separate two cognitive tasks it normally conflates. LLMs are eager to help: they jump to solutions.
The key constraint
Asking for a diagnostic first slows that down in a useful way. The agent has to articulate what's wrong before it proposes what's right.
That constraint almost always produces better analysis, and better analysis produces better fixes.
Whether you're writing code or writing prose, the principle is the same: the agent produces better output when it first produces an honest account of what's wrong.
Loops try to automate the judgment. Metrics put it back in your hands.
I know which one I'd rather have.