Loop engineering

Loop engineering

Loop engineering is designing AI work as iterative cycles — act → observe → verify → repeat — that continue until a verifiable goal is met, instead of a single one-shot response. One-shot generation can't catch runtime errors, adapt to environment quirks, or confirm its output actually works; a loop closes that feedback gap. With agentic coding, quality is usually determined by the loop design (error handling, context across iterations, scoping, verification) more than by the base model.

When to use a loop

Use a loop when the number of steps can't be predicted up front, the agent must adapt to intermediate results, and there is a way to check success (tests, type-checks, a reproducible command). Skip the loop for trivial, single-step edits.

Anatomy of a good loop

1. Clear goal — specific, scoped, with testable success criteria.
2. Tool access — code execution, filesystem, shell, test runners.
3. Context management — keep the goal and the latest verify output in front of the model; read state from disk rather than relying on a growing transcript.
4. Termination logic — success (verify passes), failure (max iterations / no progress), and an escalation path to a human.
5. Error recovery — distinguish recoverable errors from hard blockers; never retry an identical failed approach.

Verification: deterministic over self-assessment

Gate the loop on a deterministic check — a command that exits 0 only when the work is correct (npm test, pytest, tsc --noEmit, cargo build). Deterministic checks scale and are trustworthy; LLM self-evaluation adds cost and can hallucinate "done". Use a completion-promise string only when no command can express success.

Guardrails (failure modes are routine, not edge cases)

• Hard iteration cap — always set --max-iterations so the loop is bounded.
• No-progress detection — stop if results are identical across consecutive iterations (stuck), instead of burning the whole budget.
• Human checkpoints — pause before irreversible or outward-facing actions.
• Scope — a vague goal causes drift; write criteria a command can check.

Using this plugin

• /loop-engine:plan "<goal>" — design a loop (plan + verifiable criteria + verify command) without running it; delegates to the loop-planner agent.
• /loop-engine:start "<goal>" --verify "<cmd>" --max-iterations <N> — start the loop. A Stop hook re-runs the verify command each turn and re-injects the goal + failure output until it passes, the iteration cap is hit, or no progress is detected.
• /loop-engine:status — inspect iteration count and the last verify result.
• /loop-engine:stop — cancel the active loop.

When running inside a loop, on each turn: read the re-injected verify output, make one concrete change toward the goal, re-run the verify command yourself, then yield. Don't repeat approaches that already failed.