The loop: prompt, look, redirect

The thing nobody tells you about building software by talking to an agent: the first version is supposed to be a little wrong.

If you came in expecting to write one perfect sentence and receive finished software back, the first reply is going to feel like a letdown. The buttons are in odd places. It guessed at something you never said. It built the wrong half of what you meant. And the temptation, right there, is to conclude you're bad at this — that real builders just know the magic words.

They don't. There are no magic words. What experienced people have is not a better first prompt; it's a loop they trust. They say what they want, they look hard at what came back, and they say the next thing. Over and over, until it's right. That loop is the whole skill. Once you're running it on purpose instead of stumbling through it, you're building software — even if you've never written a line of code.

one prompT is a wisH. a loop iS a method.

Here's the trap. A single prompt asks the agent to read your mind. You're holding a full picture in your head — the feel of the thing, who it's for, what matters and what doesn't — and you're trying to squeeze all of it through one paragraph. No human colleague could build the right thing from that paragraph either. They'd build a thing, show it to you, and ask "like this?"

That question — like this? — is the loop. It has three beats, and you run them in order:

• Prompt. Say what you want, plainly. Don't agonize over getting it perfect — you're starting a conversation, not casting a spell.
• Look. Actually examine what the agent built or proposed. Not "does it sound right" — is it right. This is the beat people skip, and skipping it is where projects quietly go wrong.
• Redirect. Tell it what's off and which way to go. Specific, concrete, one or two things at a time. Then you're back at the top.

The work isn't front-loaded into one heroic prompt. It's spread across the turns. That's not a workaround for the agent being dumb — it's how building has always worked, finally made fast enough that you can do a full lap in a minute instead of a week.

a real lAp, staRt to fInish

Let's watch one. Say you want a little page where people sign up for a workshop. Here's a perfectly good opening prompt — note how unfussy it is:

The agent goes off and builds something, and shows it to you. It's a clean form. Three time slots. It even picked a soft clay-colored background, which is a nice touch you didn't ask for. But when you look, you notice two things: there's no way for someone to leave a note (a few people always want to ask about materials), and the three slots are just plain text, so two people could pick the same full slot.

That's your redirect. You don't start over. You don't re-explain the whole thing. You name exactly what you saw:

The agent already knows what it built — it has the whole prior context — so it adjusts just those two things and shows you again. Now there's a notes box, and the slots read “Saturday morning — 3 of 8 left.” You look again. Maybe it's right and you're done. Maybe you realize the “3 of 8” should turn red when it's nearly full, and around you go one more time. Each lap is small. Each lap is cheap. That's the point.

Notice what made the redirects work: each one was about the result you saw, not a vague vibe. “Make it better” gives the agent nothing to aim at. “Add a notes box and show remaining spots” gives it a target. The clearer your look, the sharper your redirect.

you are sTill the One who Decides

It's easy to read “the agent builds it” as “the agent is in charge.” It isn't, and that distinction is the most important thing in this whole lesson. Handing the labor to an agent is not handing over the judgment. Delegation is not abdication.

Think about how a good editor works with a writer, or a client with a contractor. The contractor does the building. The client still walks the site, says “that wall's in the wrong place,” and signs off on what's right. Nobody thinks the client became a bricklayer, and nobody thinks the client stopped being in charge. You're the client. The agent is doing real work, fast, but you are the one who looks at each result and decides whether it's good enough or needs another lap.

That “look” beat is not optional, and it's not busywork. It's the entire reason the thing comes out right. An agent will happily build something confident and wrong. It doesn't know your taste, your customers, or the thing you didn't think to say out loud — until you tell it. The loop is how you tell it, one observation at a time.

why thiS is saFe to dO fast

Running a tight loop only feels reckless if you're afraid a wrong turn is permanent. It isn't. Because of how a workbook keeps its own history — every change recorded, with a way back — an agent working this way leaves a trail you can read and undo. You can try a bold redirect, look at it, hate it, and go back. The cost of a bad lap is one more lap. That's what makes “just try it and see” a real strategy here and not a gamble.

It also means you never have to guess what the agent did between your check-ins. The work records itself — what it changed, and why. So “catch me up” is an answerable question, and your look beat has something concrete to look at, even on work that happened while you were away.

where this Is honest, And where It's headed

One straight thing: the loop you just learned is the part that works today. You really can prompt, look, redirect, and watch software take shape in front of you, with the human — you — staying in the driver's seat the whole time. That's not a promise about the future; it's the everyday motion of building here.

The longer arc — the one this Learning Center keeps pointing at — is that the same homogeneous, self-recording system that makes your loop legible can eventually let parts of the work tend themselves: an agent that notices it lacks a capability and files that gap for later, software that improves between your visits. That's the north star, and it's genuinely aspirational, not a thing you flip on tomorrow. But it grows out of exactly this loop. The pitch was never “software that runs itself.” It's software built in workbooks — by people and agents, together, one honest lap at a time.

So that's the move that turns “I can't code” into “I can build.” Not a perfect prompt — a loop you run on purpose. Say what you want. Look hard at what came back. Redirect toward what's right. You stay the reviewer; the agent stays the builder; and the thing gets better every time around.