Loop Engineering, Explained with Dirty Dishes! 🍽️

Why the newest AI tools don't just answer you. They try, check, and try again. Someone has to design that.

The latest idea making the rounds in AI tools is Loop Engineering. In this post, I’m going to take a few moments to explain what loop engineering is at a high-level and then have a follow-up where we actually build a system using it.

Setting the Stage

Here’s a question that sounds silly until you sit with it: after an AI gives you its first answer, what should happen next? For most of AI’s history, the answer was nothing. You asked, it answered, the end:

But the tools / agents getting attention right now behave differently. You give them a prompt. They create a goal, write a sequence of steps, and start taking action. Over the course of them running, they will do one of three things:

1. Reach their goal and let you know they’ve completed the task

2. Notice that they may be drifting further away from the goal, start course correcting, and keep going until they are back on track

3. Realize they are lost and ask a human for help

This keep going behavior doesn’t happen by accident. Someone designs it: what the AI tries first, how it checks its own work, when it stops, when it gives up and asks a human. That design discipline is called loop engineering. This design is the difference between an AI that just answers once and hopes for the best, and one that actually checks its own work and fixes its mistakes.

Meet the Dishwasher Test

Forget computers for a minute. Imagine you’ve hired two people to wash dishes:

Our first dishwasher is Ralph. He takes a plate, scrubs it once, and puts it in the rack. Done. Doesn’t look at it. If there’s dried pasta sauce still welded to the rim, that’s now your problem. Every plate gets exactly one scrub, no matter what:

It’s a different story with Lisa. Lisa scrubs the plate, then holds it up to the light. Still greasy? Back in the sink. Scrub, check, scrub, check. The plate only reaches the rack when it’s actually clean:

And if some pan is so burnt that ten rounds of scrubbing do nothing, she doesn’t scrub for eternity. She sets it aside and asks you whether it should soak overnight or just get thrown out:

Notice something important: both Lisa and Ralph might be equally good at scrubbing. The cleaning technique could be identical. What separates them is everything that surrounds the scrubbing. The checking, the repeating, the knowing-when-to-stop. Lisa isn’t more talented. Lisa simply has a better process.

Loop engineering is designing Lisa’s process, but for AI.

Historically, AI was like Ralph

When you ask a chatbot a simple question, it’s doing the single-scrub thing, and that’s totally fine. A question like How long do I boil an egg? needs only a single pass. There’s nothing to inspect, no dried sauce to catch. One scrub, into the rack, everyone’s happy.

The trouble starts when the task has more than one step and a real definition of done! Say you ask an AI to build you a small website. A Ralph-like AI generates a pile of code in one go and hands it over:

Maybe it works. Often it sorta kinda almost works, which is worse, because now a person who may not read code is staring at a broken page with no idea which line is at fault. The AI did its scrub. It never held the plate up to the light to check for completeness.

You might think the fix is a better scrubber, meaning a smarter AI that nails everything in the first try. Researchers chased that for a while. But even brilliant humans don’t write flawless code on the first attempt, and it turns out first-try perfection is the wrong goal entirely. The fix isn’t a better scrub. It’s adding the checks to make sure the result is what you would expect.

Meet the Loop

So what does the check-and-repeat cycle actually look like inside an AI system? We can generalize by looking at four stages, going around and around:

What each stage means is:

• Try. Do a piece of the work.

• Check. Look at what actually happened, not what was supposed to happen.

• Judge. Compare reality to the goal. Clean plate or greasy plate?

• Adjust. If it’s not done, change something based on what the check revealed, and go around again.

Tying it all together, loop engineering is the difference between doing the work once and getting the work done. The loop makes a bunch of small attempts instead of one heroic one, and each attempt is a little wiser because of what the previous check revealed. The AI doesn’t stop when it feels finished. It stops when the checks agree it’s finished, or when it knows it’s time to hand the pan to a human.

The Idea Behind Loop Engineering Isn’t New

If this whole loop thing feels familiar, it should. We have numerous examples of loops that run and course correct today. Your home thermostat runs one: measure the room, compare to the setting, heat or don’t, measure again. Cruise control runs one with speed. There have even been mechanical loops such as the governor on old steam engines:

The governor kept them from spinning out of control and exploding. As the engine spins, centrifugal force flings the metal balls outward and upward to choke the steam valve if it goes too fast, or drops them to open the valve if it slows down too much.

With these loops, the goal was a crisp target, and you always knew whether you would hit it. The room temperature is 70 degrees. The speed is 65mph. The steam engine is running within a narrow range. The new and genuinely hard thing is running feedback loops where “done” is fuzzy. Is this code correct? Is this email’s tone right for a customer who’s already annoyed? Is this research summary complete or just confident? The loop’s skeleton is the thermostat’s. The judgment inside it is a much wilder animal, and that’s where good loop engineers are important.

Three Questions Every Loop Must Answer

Building a loop that tries and checks is the easy part. The craft is in three deceptively simple questions:

• What does “clean” mean? The loop needs a test for done that it can actually run. Vague goals produce loops that either quit early with greasy plates or polish forever. Much of loop engineering is turning “make it good” into something checkable.

• When do you stop scrubbing? Every trip around the loop costs time and money. A loop with no exit limit will happily burn an afternoon nudging a comma back and forth. Good loops have a budget and know when returns have diminished.

• When do you set the pan aside? Some problems don’t yield to more scrubbing. The best-designed loops detect that they’re stuck, stop, and hand the pan to a human with a clear note about what they tried. A loop that can’t admit defeat is more dangerous than one that never tries, because it fails silently and expensively.

Notice that none of these questions are about making the AI smarter. They’re about restraint, self-awareness, and knowing when to escalate.

Why This Matters

You’re going to be choosing between AI tools for years to come, and the marketing will all sound identical. The good news is there’s an easy way to tell them apart: the quality gap between AI products is increasingly a loop gap, not a brains gap. Many tools are built on the same handful of underlying AI models. The one that feels magical and the one that feels flaky often differ mainly in how well their loops are engineered. Does it verify before it delivers? Does it stop at sensible points? Does it ask you when it’s stuck, or does it guess?

So when you try an AI tool, don’t just admire its first answer. Give it something with a few steps and watch what happens after the first attempt. Does it hold the plate up to the light? That single habit, designed by someone you’ll never meet, is most of what separates a tool you demo once from a tool you rely on.

Till Next Time

Next up is for you to learn how to build your own loop that you can use as part of your AI workflow and see everything we talked about in action. That’s going to be a hoot.

If you have any questions or comments, feel free to reach out to me by replying to this email, tweeting / x-ing, or by posting on the forums!

Cheers,
Kirupa 🥳