/loop

Every AI conference this year was about loops. Here's what that means for design, and a loop you can run in the next ten minutes.

Photo by Google DeepMind

In the space of one month, the AI engineering world fell in love with /loop.

Peter Steinberger said stop prompting your agents, start designing loops that prompt them. Boris Cherny at Anthropic said he doesn’t write prompts anymore, he writes loops and the loops do the work. Then came the essays, Loop Engineering, Loopcraft, The Art of Loop Engineering, one after another. By the time the AI Engineer World’s Fair opened, the word owned the main stage. Swyx keynoted about them. An entire track was devoted to them. The conference closed with an hour-long debate about whether the hype had already outrun the practice.

This whole time, designers have been doing loop work.

---

What is /loop?

When an AI agent runs, it doesn’t do one thing and stop. It cycles: it gets an instruction, takes an action, checks the result, decides what to do next. That cycle repeats, sometimes dozens of times, before anything reaches a human. The engineers building these systems have mapped out five distinct loops nested inside each other, from the execution loop at the bottom (the model runs) to the oversight loop at the top (a human decides if any of it was right).

The oversight loop is where Laurie Voss, Head of Developer Relations at Arize, says you should live. He literally labeled it in his diagram with the words: “you should live here.” Swyx mapped the stack and Voss named the top loop and gave it an exit condition:

Voss was writing for engineers. He meant: don’t get lost in the execution details. Stay at the level where judgment lives.

---

The Designer’s Loop Stack

That’s Swyx and Voss’s stack, built for engineers. Here it is again, same five layers, mapped to what each one means for design work.

At the base: the execution loop. The model fires, tool calls happen, tokens generate. This is genuinely not your concern. You don’t need to understand transformer architecture to design well with AI, any more than you need to understand TCP/IP to design a good website.

One layer up: the task loop. The agent works on a specific thing until a condition is met, then stops. Who defines that condition? You do. “The task is complete when the output meets the brief” is a design decision. What counts as meeting the brief is yours to specify.

Then the product loop. This is the experience layer, the thing a person actually encounters. Does the flow hold together? Does the output feel like it belongs to a coherent system? Does it match the quality bar? Every heuristic you’ve ever learned, every design principle you’ve internalized, lives here.

Then the system loop. This is where the AI gets better, or doesn’t. The patterns it learns, the constraints it operates within, the values it embodies. Design systems, behavioral specifications, brand guidelines, content principles, tone of voice. Everything you’ve encoded about what good looks like. This is the layer that trains the loops below it.

At the top: the oversight loop. This is where human judgment lives permanently. Not as a checkpoint at the end. Not as a review gate before launch. As a continuous presence that can redirect anything in the stack at any time.

This is what we call “craft”.

---

Try It

Open whatever agent you have handy, Claude, ChatGPT, Cursor, whatever’s already in your browser, and paste this in.

You’re going to play the oversight loop.

You and I are going to run a design loop together.
I'm the oversight loop. You run everything below me.

STEP 1 - I set the goal and the quality bar.
My design task: [describe what you want made]
My quality bar, which is your exit condition: [list your criteria,
the specific things that have to be true for this to be good]

STEP 2 - You run the task loop.
Generate a first attempt.

STEP 3 - You run the critique loop against MY bar, not your own.
Score the attempt against each criterion I set. Name what fails.

STEP 4 - You revise, then repeat steps 2 and 3.
Keep looping until every criterion is met, or until you've tried 4 times.

STEP 5 - You stop and hand back to me.
Show me the final version. Tell me which exit you took: did you meet
the bar, or run out of tries?

Then wait. I decide whether to accept it or send you back down with a
sharper bar. That decision is the one you can't make, it's my call.

If you'd rather watch it work before you write your own, paste this filled-in version instead. It's the empty-state copy for a savings screen, a real design task, run all the way through.

You and I are going to run a design loop together.
I'm the oversight loop. You run everything below me.

STEP 1 - I set the goal and the quality bar.
My design task: Write the empty-state copy for a budgeting app's
savings screen, the moment before a user has saved anything.

My quality bar, which is your exit condition:
- reassuring, never preachy
- under 15 words
- no finance jargon
- offers one clear next action

STEP 2 - You run the task loop.
Generate a first attempt.

STEP 3 - You run the critique loop against MY bar, not your own.
Score the attempt against each criterion. Name what fails.

STEP 4 - You revise, then repeat steps 2 and 3.
Keep looping until every criterion is met, or until you've tried 4 times.

STEP 5 - You stop and hand back to me.
Show me the final version and tell me which exit you took.

Then wait for my call.

Watch what happens: The agent generates, checks its own work against the bar you set, rewrites, checks again. The inner loops spin in front of you. Then something small and important happens: it stops. It shows you what it made, tells you how it exited, and waits.

That pause is the whole thing. The agent did the generating, the critiquing, the revising, all of the work we used to spend time on. It still couldn’t take the last step. Someone has to decide whether the bar was the right bar, whether good enough is actually good enough, whether this is worth shipping to a real person on the other end.

---

This Perspective Shift

The conversation about AI and design tends to run in one direction: here are tools you can use to do your job faster. That framing keeps designers in the task loop. Tools help you execute. The loop stack shows you where the real work is.

The real work is authoring the system loop. Writing the specifications that constrain how AI behaves. Encoding the quality standards that define what good output looks like. Making the judgment calls that no loop below the oversight layer can make on its own.

This is alignment work. It’s the work that determines whether an AI system produces something trustworthy or something that looks right and isn’t. It is, in the most literal sense, design work. We’ve been doing it every time we wrote a design principle, defined an error state, built a content model, ran a heuristic evaluation, or wrote a brief that was precise enough to actually constrain what came out the other end.

The engineers are building the loops. We need to understand the stack well enough to know which layer our decisions live at, and which layers we’re accountable for.

---

How to use this in practice

Next time you’re working on something with AI, ask yourself four questions before you start:

1. What is the exit condition for this task? If you can’t answer that precisely, the task loop has no floor. You’ll know it’s done when you feel it’s done, which means you’re making a judgment call you haven’t made explicit yet. Make it explicit.

2. What quality bar does the product loop need to meet? Not “it should be good.” What does good look like, specifically, for this output, for this audience, in this context? Write it down. That’s your design brief, and it’s also the only thing standing between you and an agent that produces plausible-looking nonsense.

3. What does the system need to know to do this well? What knowledge, what constraints, what values need to be in the system loop for the output to be trustworthy? This is where your domain expertise becomes the thing you encode, not just the thing you use.

4. What would make me override this entirely? The oversight loop exists because some things can’t be delegated. Knowing your own override conditions before you see the output is the difference between judgment and reaction.

These are the design practice applied one layer down.

---

/loop is already for you

The loop stack wasn’t created for designers. It was built by people thinking about how to architect reliable AI systems. The role they reserved at the top of the stack, the one they labeled “you should live here,” is a designer’s role.

It requires taste. It requires the ability to hold a quality bar under pressure. It requires knowing what the humans on the other end of this system need, and being willing to say when the output doesn’t meet it.

The most interesting conversations shaping this era of AI are happening in rooms designers don't usually enter, in communities we haven't typically joined. That needs to change. Show up at the AI engineering conferences. Show up at the AI science ones. Make sure design has a voice in the room, and is learning in real time alongside everyone else.