If you feel like you are spending more time babysitting your AI coding assistants than actually writing software, you are not alone. Typing a prompt, waiting for code, copying it into your IDE, running a test, copying the error back to the AI, and repeating the cycle is exhausting. It keeps your hands tied to the keyboard for tasks that should be automated.
The unit of work has shifted. The industry evolved from prompt engineering in 2023, to context management in 2024, and to harness engineering in late 2025. Now, in mid-2026, the engineering community has crystallized around a new paradigm: Loop Engineering.
The phrase went viral following a Slashdot feature noting that top AI creators (like Claude Code creator Boris Cherny) rarely write manual prompts anymore. Instead, they design loops that prompt the agents for them. Shortly after, Addy Osmani, director of Google Cloud, published a seminal breakdown on Loop Engineering that turned this viral trend into a concrete architectural vocabulary.
At its core, a loop is a task with a check. Instead of a single-turn instruction, loop engineering is the practice of designing a repeating cycle in which the model takes an action, receives feedback from its real-world environment, uses that feedback to decide the next move, and continues until a defined termination condition is met.
The Anatomy of an Agentic Loop#
According to Addy Osmani’s framework, a robust engineering loop relies on five core building blocks and a dedicated memory layer. When working with modern developer tools, these pieces keep the agent productive, isolated, and aligned:
- Automations: These act as the triggers. They run on a schedule, a cron job, or a git hook to kick off discovery and triage without human intervention.
- Worktrees: To prevent parallel agents from stepping on your active development or colliding with each other, each loop operates in an isolated environment (such as a dedicated
git worktree). - Skills: Rather than letting an agent guess how your specific project works, you codify institutional knowledge into structured files (like a
SKILL.mdor a configuration file) that the agent implicitly invokes. - Plugins and Connectors: These bridge the AI to your existing toolstack. Using protocols like the Model Context Protocol (MCP), loops gain access to secure terminals, compilers, type checkers, and test runners.
- Sub-Agents: Complex goals are broken down by assigning roles. One agent ideates a solution, while a separate verification sub-agent reviews the work or challenges the implementation.
- External State (The Memory Layer): Because long-running loops can easily overwhelm an LLM’s context window, tracking progress must live outside the active chat. Maintaining state in a local Markdown file (like
AGENTS.md) or syncing to an external project board ensures the loop remembers what is done and what is next without suffering context rot.
Defining the Boundaries#
Loop engineering shifts your leverage from writing sharper prose to establishing sharper boundaries. The most critical component of a loop is a stable, checkable goal.
For example, instructing an agent to “improve the code quality” is a recipe for an infinite loop because the agent never knows when to stop. Conversely, instructing an agent to “get the continuous-integration build green on the payments-refactor branch” provides a definitive, binary termination condition. The loop executes, runs the test runner via its connector, evaluates the failure, rewrites the code, and checks the build again until it passes or hits a hard limit.
Navigating the Risks#
While loop engineering offers true autonomy, it removes the human safety net, introducing unique engineering challenges:
- Token Cost Blowups: An unmonitored loop running sub-agents through endless recursive cycles can burn through API budgets rapidly. Setting hard caps on iteration counts, execution time, and max cost is essential.
- No-Progress Loops: Without proper exception handling, an agent can get stuck in a loop, repeating the exact same failing action or fixing a bug only to reintroduce a type error.
- Comprehension Debt: When an autonomous loop alters dozens of files while you sleep, your technical debt shifts into comprehension debt. You must still review, understand, and maintain the code the loop produces.
The era of manual prompting is drawing to a close. By focusing on designing autonomous loops with rigorous verification steps and clear termination boundaries, engineers can step away from the keyboard and let the system navigate the execution path independently.