@kentcdodds: Loop Engineering? Let me show you how I evolved to do that naturally and give you a pragmatic approach to it.

Loop Engineering? Let me show you how I evolved to do that naturally and give you a pragmatic approach to it.

https://t.co/EH4Ktc98yM

TL;DR

Kent C. Dodds shares how he naturally discovered and practiced “Loop Engineering”—by setting up triggers, action/observation loops, and stop conditions for coding agents, letting them autonomously do more work while trading computation for attention. He ends with a practical, ready-to-use automation assignment.

What is Loop Engineering?

At its core, Loop Engineering lets agents perform multiple rounds of operations instead of a single response. The basic elements include:

• Trigger: can be a prompt, a system event, a state change, etc.
• Stop condition: the point where human intervention is needed (in the short term, we can’t fully remove humans yet).
• Loop body: an action phase (agent executes MCP calls, CLI commands, edits, etc.) and an observation phase (getting result feedback). The goal of the loop is to have the agent do more for you before reaching the stop condition.

Kent mentions that initially we just sent a message to an LLM and it replied; later tools were added so agents could execute actions; now agents can self-loop and execute multiple rounds. Loop Engineering is about making that loop as wide as possible, covering all the steps you need.

From Manual to Natural Loops: Kent’s Evolution Path

Starting Point: TDD-style Agent Prompting

About a year ago, people started using a TDD mindset: first generate a test, then have the agent pass it. This was an early form of extending the agent loop.

Browser Mode & Playwright MCP

Before Cursor introduced browser mode, Playwright MCP already existed. When building web apps, the agent could control a browser to inspect its own work, feeding browser feedback into the loop. This helped both agent and human validate results.

Full Environment: Cursor Cloud Agent (Early 2025)

In January, Cursor added a full desktop environment for cloud agents, which was a real breakthrough for Kent.

• The agent could log into apps and save state; each new agent instance would automatically remain logged in and continue working.
• Humans could take over at any time to check the experience (e.g., what the integration page looks like), spot small errors, and have the agent fix them.
• This drastically improved review efficiency: the agent checks its own work, the human checks the agent’s work, with more focused attention.

Loop Engineering in the PR Workflow

Kent started consistently using Cursor cloud agents to handle pull requests. He found he could simply talk to Cursor inside the PR: “The Playwright test in CI failed, please fix it.” Later he went further: “Something in CI failed, go fix it.”

He realized asking the agent to check feedback manually was annoying, so he switched to a single prompt:

“Wait for CI to finish, handle failures in CI, handle valid feedback from AI review bots (CodeRabbit, Bugbot). If there are no failures or other issues, break out of the loop; otherwise push changes and repeat. When everything looks good, send me a message via Cody on Discord.”

This makes the agent loop continuously: commit → get AI feedback → process valid content → commit again → until stop. What reaches Kent is a solid PR that has passed multiple layers of AI review. He doesn’t even need to watch it; Cody (a personal assistant, MCP server) proactively notifies him when it’s done.

That’s Loop Engineering: instead of manually prompting the agent, you let the agent prompt itself, or get prompted by another agent, and you only step in when necessary.

Automation: Making the Trigger an Event

The automation feature Cursor launched this year takes Loop Engineering to the next level. Kent gives two examples:

Auto-fix Production Deployment Failure

Set up automation: if a CI job for production fails, automatically trigger a Cursor cloud agent to analyze the cause and create a PR. By the time Kent notices the deployment failure, there’s already a PR fixing it.

Nightly Documentation Check

Agents tend to treat documentation as a changelog, writing “it used to be like this, now it’s like that.” Kent set up a nightly agent to review changes from the past 24 hours, scan the docs, remove temporary or negative language (e.g., “we no longer do this”), keeping the documentation describing the current state of the system.
Also, automatically identify regression tests added for deleted features (preventing agents from carrying useless baggage), reducing unnecessary test burden.

Key point: these loops require no manual triggering from Kent. Every morning he wakes up to a PR that has already done useful work.

Costs & Caveats

Kent warns: Loop Engineering can be very expensive. You are trading computation for attention.

• If the computation does something valuable (like saving you a lot of time), it’s indeed efficient.
• But if you’re on a $20/month plan, you’ll quickly burn through your quota. Cloud VMs, browser checks, CI review bots, retries, etc. can add up to unexpected bills.
• Choose wisely: only put tasks into Loop Engineering that are valuable, repetitive, and well-suited for automation.

Your Assignment: Create a Useful Automation

Pick your preferred coding agent, find a loop you’re currently running manually (e.g., “Hey, go change this, now CI is broken”), and let the agent automate it. Try to have the agent loop on its own until it hits a stop condition, instead of you prompting it each time.

Summary

• Good agents make code generation cheaper
• Good loops make work validation cheaper

Kent believes Loop Engineering is a stepping stone; future coding agents will bake it into their operation model. Starting today allows you to stay ahead of future versions and take advantage of agent improvements faster.

Source: @kentcdodds: Loop Engineering? Let me show you how I evolved to do that naturally and give you a pragmatic approach to it. (https://www.youtube.com/watch?v=jCZKiHrUNT4&list=PLV5CVI1eNcJhP4nrJt85L7PxHjebFpDfY)