Anthropic’s Official Loop Engineering Guide Revealed

Four Loop Types, Not Four Mutually Exclusive Functions

Claude Code team defines a Loop as an Agent repeatedly executing a work cycle until a stop condition is met. Classification considers how to trigger, how to stop, which primitives to use, and suitable tasks.

Turn‑based Loop

You issue a Prompt; the Agent gathers context, acts, checks, and repeats if necessary, finally returning a result. The delivery to the Agent is the "check" within a single task, while the decision to start another round remains with the user.

---
name: verify-frontend-change
description: Verify any UI change end-to‑to end before declaring it done.
# Verifying frontend changes
Never report a UI change as complete based on a successful edit alone. Verify it the way a human reviewer would:
1. Start the dev server and open the edited page in the browser.
2. Interact with the change directly. For a new control (button, input, toggle): click it, confirm the expected state change, and screenshot before/after.
3. Check the browser console: zero new errors or warnings.
4. Use the Chrome Devtools MCP, run a performance trace and audit Core Web Vitals.
If any step fails, fix the issue and rerun from step 1 — do not hand back partially verified work.

Goal‑based Loop

When a single round is insufficient, you write a /goal that specifies "what counts as done". Each time the Agent wants to stop, an evaluator checks the condition; if unmet, the loop continues until the goal is satisfied or a round limit is reached. Here you deliver the stop condition.

/goal get the homepage Lighthouse score to 90 or above, stop after 5 tries.

Time‑based Loop

The /loop command repeats a prompt at a set interval on the local machine, while /schedule moves the task to a cloud schedule. It suits checking PRs, summarizing messages, or monitoring external systems. Here you deliver the trigger.

/loop 5m check my PR, address review comments, and fix failing CI

Proactive Loop

Triggered by events or schedules, it does not require a human to be present. Internally it can combine /schedule, /goal, Skills, dynamic workflows, and Auto mode. Even the next prompt can be chosen by the system.

/schedule every hour: check the project‑feedback channel for bug reports.
/goal: don't stop until every report found this run is triaged, actioned, and responded to. When fixing a bug, use a workflow to explore three solutions in parallel worktrees and have a judge adversarially review them.

The key progression is verification → stop condition → trigger → prompt itself . The farther right the design moves, the more judgment is handed over to the system and the greater its responsibility.

The Real Difficulty Is Writing an Unfalsifiable Completion

Many newcomers mistake a Loop for merely "making the Agent run more rounds", which is the most dangerous misunderstanding. If the goal is vague like "optimize the homepage", the Agent may declare completion subjectively. A quantifiable target such as "Lighthouse score ≥ 90, max 5 attempts" forces the evaluator to check a concrete condition. The official guidance stresses that measurable verification standards outweigh longer, fancier prompts.

Skills form the infrastructure for turn‑based loops. By encoding manual acceptance steps in a SKILL.md, the Agent can open pages, interact, check consoles, and run tests, thereby simulating a real delivery feedback loop rather than stopping after code changes.

Goal‑based loops hinge not on the presence of a /goal command but on answering four questions:

- What evidence shows the task is complete?
- Who validates that evidence?
- After how many consecutive failures must the loop stop?
- When permissions, cost, or context are insufficient, when must a human be called?

Without clear answers, loops quickly produce results that cannot be accepted.

Autonomy Is Not Free Lunch

Token consumption is a critical cost factor. Dense polling in time‑based loops, vague exits in goal‑based loops, or unrestricted sub‑Agent spawning in proactive loops can silently inflate expenses.

Claude’s official cost guardrails advise:

Use smaller, faster models for simple tasks.

Write explicit success and stop conditions.

Pilot large‑scale runs with small slices first.

Assign deterministic steps to scripts.

Match schedule frequency to real‑world change speed.

Monitor consumption with /usage, /goal, and /workflows.

The underlying truth is that loops themselves do not save money; clear boundaries, model tiering, and deterministic tools do.

Quality follows the same pattern: the system must keep the codebase tidy, documentation accessible, enable the Agent to self‑validate, and allow a second Agent to perform an independent review. Otherwise, higher automation merely spreads errors faster.

Final Checklist

Can I first deliver verification steps ?

Can I write verifiable stop conditions ?

Is the work truly worth delegating to a trigger based on schedule or event?

When the system can choose the next prompt, am I prepared with permissions, budget, and human escalation paths?

This creates a safer automation ladder: identify the bottleneck step, hand it out, and add a layer of verification and boundary for each additional judgment the system assumes.

Loop Engineering ultimately is not about making the Agent run longer, but about knowing when to continue, when to stop, and when to hand control back to a human.

https://x.com/ClaudeDevs/status/2074208949205881033
https://x.com/op7418/status/2074364045294293191