Reading list

The sources below are the canon behind loop engineering. Every URL was fetched and confirmed to resolve (July 2026); two URL corrections are noted inline. Each entry ends with the pattern it contributes to the taxonomy.

The naming layer

What the discipline is called, and by whom.

Loop Engineering — Addy Osmani, 2026. The clearest primary statement: “loop engineering is replacing yourself as the person who prompts the agent, you design the system that does it instead.” Frames the loop as shipping primitives plus externalized state, and names the sycophancy trap (a model is too nice grading its own homework). Contributes: the layer model, loop engineering as the floor above harness engineering.

Building Effective Agents — Erik Schluntz & Barry Zhang (Anthropic), Dec 2024. The foundational taxonomy everyone builds on: the workflow-versus-agent distinction and five composable patterns. Names coding as the killer agent domain precisely because solutions are verifiable through automated tests, plus the doctrine “add complexity only when it demonstrably helps.” Contributes: evaluator-optimizer.

“An LLM agent runs tools in a loop to achieve a goal” — Simon Willison, Sept 2025. The canonical minimal definition: tools in a loop (the harness feeds results back) to achieve a goal (a stopping condition, explicitly not an infinite loop). Contributes: the irreducible agent loop.

The practitioner harness layer

How working engineers actually build and run loops.

Best practices for Claude Code — Anthropic, living doc. Home of the explore → plan → code → commit workflow and the rule “give Claude a way to verify its work”: give it something that produces a pass or fail, and the loop closes on its own. Contributes: a machine-readable pass/fail target the agent self-iterates against.

Ralph Wiggum as a “software engineer” — Geoffrey Huntley, Jul 2025. The definitive writeup of the bare while-loop agent: same prompt, fresh context every loop, one thing per loop, progress living in files and git rather than the context window. Type systems and tests are the “back pressure” that rejects bad generations. The follow-up Everything is a Ralph Loop (Jan 2026) generalizes it. Contributes: the Ralph loop.

Just Talk To It — Peter Steinberger, Oct 2025. The essential counter-voice: runs several agents in a terminal grid and argues most harness machinery is “charade” that patches over model weakness. Coined “blast radius” as a change-sizing heuristic. Contributes: minimal-ceremony parallel agents, the argument for when not to build a loop.

How to Build an Agent — Thorsten Ball (Amp / Sourcegraph), Apr 2025. Demystifies the agent as “an LLM, a loop, and enough tokens,” a working code-editing agent in about 400 lines, mostly boilerplate. Contributes: the accumulated-context tool loop, the counterpoint to Ralph’s fresh context.

Designing agentic loops — Simon Willison, Sept 2025. The practical how-to for autonomous loops: a safe sandbox, well-documented shell commands, and above all a clear mechanical success criterion so the loop self-checks and you can walk away. Contributes: sandbox plus mechanical success check equals unattended iteration.

Agent Harness Engineering — Addy Osmani, 2026. The floor directly below loop engineering: designing the environment one agent runs inside. “It’s not a model problem, it’s a configuration problem,” so you patch the harness rather than reprompt. Contributes: configuration-as-correction.

Long-running Agents — Addy Osmani, 2026. On agents that make forward progress across many sessions over days, leaving the workspace clean enough to resume: checklist conventions, typecheck and lint hooks, a plan file, worktrees so a closed laptop does not kill the run. Contributes: durable externalized state as the spine of resumability.

Best practices for coding with agents — Lee Robinson (Cursor), Jan 2026. Official Cursor guidance centered on the run-tests → fix loop, with an explicit TDD section and a long-running variant capped by a max-iteration limit. Contributes: tests-first, iterate-to-green.

How I Use Claude Code to Ship Like a Team of Five — Kieran Klaassen (Every), Jan 2026. The fleet view: multiple parallel agents, each in its own isolated copy, with the human reviewing review-ready output and acting as a manager of agents. Contributes: parallel fan-out, human as the merge gate.

Spec Kit / Spec-Driven Development — GitHub (Den Delimarsky), Sept 2025. An open-source toolkit installing a constitution → specify → plan → tasks → implement workflow, treating agents as literal-minded pair programmers that need executable specs, gated by a project constitution. See also the GitHub blog introduction. Contributes: the spec-driven fixed pipeline.

My LLM codegen workflow atm — Harper Reed, Feb 2025. A widely-cited spec-first-then-loop recipe: brainstorm a spec conversationally, break it into small TDD chunks, then execute each in a test-driven loop, with state in spec, plan, and todo files. Contributes: spec → TDD prompt-plan → per-chunk test loop.

The academic layer

The loops the practice descends from.

ReAct: Synergizing Reasoning and Acting in Language Models — Yao et al., ICLR 2023. Interleaves reasoning traces with tool actions in one rollout, so reasoning updates the plan and actions gather evidence. The template for essentially every agent inner loop. Contributes: the thought-act-observation reasoning loop.

Reflexion: Language Agents with Verbal Reinforcement Learning — Shinn et al., NeurIPS 2023. Reinforces an agent not by weight updates but by verbal self-reflection written into an episodic memory that conditions the next attempt. Contributes: the reflection/retry-with-memory loop.

Self-Refine: Iterative Refinement with Self-Feedback — Madaan et al., NeurIPS 2023. One model generates, critiques its own output, and refines, with no extra training or tools. Improves quality across tasks, but see the skeptical result below for its limits. Contributes: single-model generator-critic (self-feedback refinement).

CRITIC: LLMs Can Self-Correct with Tool-Interactive Critiquing — Gou et al., ICLR 2024. The agent validates and amends its own output by interacting with external tools (search, a code interpreter), showing that tool-grounded critique is what makes self-correction actually work. Contributes: the tool-grounded critique loop.

Voyager: An Open-Ended Embodied Agent with LLMs — Wang et al., TMLR 2024. A lifelong-learning agent combining an automatic curriculum, an ever-growing library of executable skills, and iterative prompting from environment feedback plus self-verification. Contributes: the skill-library accumulation loop.

SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering — Yang et al., NeurIPS 2024. Shows that a purpose-built agent-computer interface, not just a bigger model, is what raises resolve rates, with the agent iterating against test execution. Contributes: the agent-computer interaction loop over a designed tool surface.

Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena — Zheng et al., NeurIPS 2023. Validates strong LLMs as evaluators against human preference, and names the judge failure modes every evaluator-optimizer loop inherits: position bias, verbosity bias, and self-preference. Contributes: separate-model verification (LLM-as-judge), the trust analysis of the critic.

Large Language Models Cannot Self-Correct Reasoning Yet — Huang et al. (Google DeepMind), ICLR 2024. The load-bearing skeptical result: with no external feedback or oracle labels, LLMs generally cannot reliably self-correct reasoning and often degrade after “correcting.” Contributes: the failure-mode anchor, the proof that pure self-review needs a grounded external stop signal.