Loop Engineering Costs: What Anthropic's 4 Loop Types Actually Cost to Run (2026)

Jack Njoroge

Jack Njoroge

— 7 min read
Share
Loop Engineering Costs: What Anthropic's 4 Loop Types Actually Cost to Run (2026)

Anthropic's Claude Code team published its official definition of loops on June 30, 2026: an agent repeating cycles of work until a stop condition is met, in exactly four types: turn-based, goal-based (/goal), time-based (/loop, /schedule), and proactive. Every creator on your feed is demoing them. Almost nobody is publishing what they cost. This is the cost audit: real receipts from the people who ran each level, and the one rule that keeps you off the burn list. The short version: a properly-written /goal run costs about 200,000 tokens per feature, one full-scale workflow prompt can consume half of a $200/month plan in 30 minutes, and a badly-written goal condition can burn a full day of token allowance on a finish line that can never verify. The meter runs without you watching it.

The ladder is really four handoffs

Anthropic's four types look like they're about triggers and timers. Read their own summary table more carefully and something else is changing as you climb: what you hand off.

  • Turn-based: every prompt you've ever sent. You hand off the check, and the agent verifies its own work.
  • Goal-based (/goal): you hand off the stop. It decides when it's done, against a finish line you wrote.
  • Time-based (/loop, /schedule): you hand off the trigger. You don't start the work anymore.
  • Proactive: you hand off the prompt itself. The work finds the agent.

The term "loop engineering" comes from Addy Osmani's essay, written after Boris Cherny, the creator of Claude Code, said the quiet part out loud: "I don't prompt Claude anymore. My job is to write loops." What the hype cycle keeps missing is the other side of that trade: every handoff you climb multiplies what the loop can do and what it can spend.

Level 1: hand off the check (cost: pennies)

Turn-based is where you already live, and because you're the one checking, it's nearly free. The upgrade at this level isn't a command. It's a verification skill: ~10 lines of markdown that say never report a UI change as done just because the edit succeeded; start the dev server, open the page, click the thing, screenshot it, check the console. Anthropic's own post ships a verify-frontend-change SKILL.md as the canonical example. You write your checking behavior down once, and every future prompt gets shorter.

Receipt: pennies. But you're still the trigger and still the stop.

Level 2: hand off the stop (this is where wallets go to die)

/goal runs two AIs: a worker doing the job, and a small, fast evaluator that checks the worker after every turn, asking one question: is the finish line crossed? It can't get bored and it can't stop early. That's the superpower and the trap, because the evaluator can only verify what you gave it. It reads the transcript, not your intentions.

The receipts, from the people who ran it:

  • The failure mode: Tristen O'Brien (267K views) gave /goal conditions like "make no mistakes" and "do a good job" (his words) and burned a full day of his token allowance on goals that could never come true. The evaluator can't verify vibes, so the worker just kept working.
  • The success case: AI LABS ran a properly-written goal, pass every test, and it worked: one feature, ~39 minutes unattended, 200,000+ tokens. Worth it for them, because the tests made "done" verifiable.
  • The scale case: one /goal can build a full application overnight. Same math, bigger bill.

Which produces the most valuable sentence in this essay: a goal is a measurement, a threshold, and a cap. "Lighthouse score 90 or above, stop after 5 tries." A number, a line, a seatbelt. If your finish line has no number, you haven't written a goal. You've written a subscription.

The bill, lined up

Run

Cost

Source

One feature via verified /goal

~39 min, 200K+ tokens

AI LABS' own numbers

One dynamic-workflow prompt at full scale

~30 min, half a $200/mo plan

Nate Herk's own numbers, on camera

Vague goal conditions ("make no mistakes")

a day's token allowance, zero output

Tristen O'Brien's own admission

One month of always-on loops, unlimited budget

reportedly $1.3M in tokens

the Steinberger report that started the "slop machine" debate

The pattern is not "loops are expensive." The pattern is: the meter runs without you watching it. Five rules from the people who paid these bills (several straight from Anthropic's own token guidance):

  1. Right-size the model. The evaluator is a small model; routine runs are a small model; the frontier model is for judgment calls only. Model choice is the biggest lever on the bill.
  2. Every goal gets a cap, turns or minutes. Always.
  3. Pilot on 5 items before you point a loop at 500.
  4. Deterministic steps become scripts, not reasoning. Reasoning is the expensive part.
  5. Read /usage weekly. The command exists because people don't.

Level 3: hand off the trigger (surprisingly kind receipts)

Some work isn't a task, it's a watch: a PR waiting on CI, reviews trickling in. /loop re-runs a prompt on an interval while your session is open, and the canonical demo isn't from a hardcore engineer: product leader Claire Vo built a daily 10:15 AM loop that reviews aging pull requests, pings her team, and spins up its own subagents.

The economics are the friendliest on the ladder: a check that finds nothing costs almost nothing; the interval loop only spends real money when something changed. Two gotchas from the field guides: /loop is session-scoped (close the laptop, it dies) and fires only when the session is idle. For anything that should outlive your laptop, promote it to /schedule, the same prompt running as a cloud routine. And give your loops memory outside the conversation (a state file, a board, GitHub Issues) so every run knows what the last run did.

Level 4: hand off the prompt (real, spectacular, and where the biggest receipts live)

The reveal in Anthropic's post is that the proactive loop isn't a new feature. It's the first three levels combined. /schedule (check the inbox every hour) + /goal (don't stop until every item is triaged and actioned) + verification skills (every fix checked end to end), plus two pieces of glue: a workflow that tries fixes in parallel with a judge agent picking them apart (the fixer never grades its own homework), and auto mode so it doesn't wake you at 3 AM asking permission.

It works outside keynotes: Anthropic's own workshop demo has the routine reading the repo overnight so the PR is waiting with your coffee. At full scale it looks like 41 scoring agents running in parallel, which is exactly the half-a-plan-in-one-prompt receipt from the table above. And the honest texture: a 35-minute unattended content run where a reviewer agent catches unsourced claims and forces a rewrite. It's not magic. It's a system you own and tune.

The verdict, level by level

Level

Handoff

Verdict

1. Turn-based

The check

Pennies

Be here by tonight. It's a markdown file.

2. /goal

The stop

200K tokens/feature when written right; a day's allowance when written wrong

Best leverage-per-dollar in AI right now, if your goal is a measurement, a threshold, and a cap

3. /loop, /schedule

The trigger

Nearly free to idle

Perfect for anything you keep checking manually

4. Proactive

The prompt

The biggest receipts on the ladder

Real. Spectacular. Climb to it, don't start on it.

You're not the prompter anymore. You're the person who reads the PRs and improves the system. That's the job Cherny was describing, just with a meter attached.

FAQ

What is loop engineering? Loop engineering is the practice of designing AI agent loops (trigger, work cycle, verification, and stop condition) instead of prompting an agent turn by turn. The term comes from Addy Osmani's 2026 essay, prompted by Claude Code creator Boris Cherny's line: "I don't prompt Claude anymore. My job is to write loops."

What are Anthropic's 4 types of AI loops? Turn-based (you check each turn), goal-based (/goal, where an evaluator checks a stop condition you wrote), time-based (/loop re-runs on an interval in-session; /schedule runs as a cloud routine), and proactive (a scheduled goal-based routine with verification: the other three combined).

How much does a /goal run cost? A documented properly-written run (pass every test) took ~39 minutes and 200,000+ tokens for one feature. A badly-written goal ("make no mistakes") burned a full day of one user's token allowance with nothing to show, because the condition could never verify.

How do you write a goal condition that won't burn tokens? Make it a measurement, a threshold, and a cap: "Lighthouse score ≥ 90, stop after 5 tries." If the finish line has no number, the evaluator can't verify it and the worker never stops.

What's the difference between /loop and /schedule? /loop is session-scoped and only fires when your session is idle: close the laptop and it dies. /schedule runs the same prompt as a cloud routine that outlives your machine.

Is loop engineering worth it? Levels 1-3, almost unconditionally: verification skills cost pennies, capped goals are the best leverage-per-dollar in AI right now, and interval loops are nearly free to idle. Level 4 is real but carries the biggest bills. Climb to it, don't start on it.

Get the Loop Pack (free)

Everything for levels 1 and 2 is in the free Loop Pack inside The New Operators: the verification SKILL.md from the video, a 12-condition /goal library (every finish line pre-capped), the PR-babysitter loop prompt, and the full proactive routine template with cost guardrails baked in. Ten minutes to your first loop. → Join The New Operators (free)

Sources

Read more