The Human in the Loop

The loop has four steps, and it matters that only one of them belongs to the machine.

1. Direct (you). You frame the task and write the prompt: the role you want the AI to take, the task itself, the constraints, the output format, any examples. Most of the quality of what comes back is decided here, before the AI does anything - which is why Module 1.2 is devoted to prompting. Directing is not typing a wish; it is specifying a task well enough that a fast, literal, context-blind assistant can attempt it usefully.

2. Generate (AI). The AI produces - options, a draft, a summary, an analysis, an image. This is the one step you delegate, and it is where the speed and volume come from. Give it room to be plentiful and imperfect; you are going to filter.

3. Evaluate (you). You judge what came back: Is it true? Is it useful? Is it on-brief? Does it fit the real client, site and budget the model never knew? This is the step people skip when they are busy or impressed, and it is the most important one - the point where hallucinations get caught and plausible-but-wrong output gets stopped.

4. Refine (you). You act on the judgement: re-prompt with a sharper instruction, pick and combine the good parts, correct the errors, or discard it entirely and change approach. Then you round again. Three of the four steps are yours. The AI never evaluates its own work or decides it is done - that is structurally your job, and it is why the loop is called human-in-the-loop.

It is worth dwelling on the balance of effort. The AI's single step, generate, is the one that feels like the miracle - text or images appearing in seconds - so it draws all the attention. But the value of the finished work is set overwhelmingly by the three human steps around it. A vague direction yields vague output no amount of AI cleverness can rescue; a skipped evaluation lets errors through untouched; a lazy refine settles for the first plausible thing instead of the right thing. In practice, the designers who get remarkable results from AI are not the ones with secret prompts - they are the ones who direct precisely, evaluate honestly, and refine relentlessly. The machine is doing the easy part.

It is tempting, especially with today's polished output, to let the loop close itself - to accept the first plausible answer, or to wire tools together so the pipeline runs end to end with no one looking. Resist this, for three connected reasons.

Because the AI cannot tell true from plausible. As Lesson 0.3 established, a model produces statistically likely output, not verified truth, and its errors look identical to its successes. Only a human who knows the subject and the context can catch a confident, well-formatted, wrong answer. Remove that human and nothing does.

Because accountability cannot be delegated. When work goes out - to a client, a contractor, a building authority - a person is responsible for it, professionally and legally. A model has nothing at stake and cannot answer for a mistake. If you did not evaluate the output, you are signing your name to something no one judged. Closing the loop is what makes the work genuinely yours to stand behind.

Because it keeps you the author. The evaluate-and-refine steps are where your design intent, taste and context re-enter the work and bend the generic toward the specific. Skip them and the output drifts to the average - competent, plausible, and indistinguishable from everyone else's. The loop is not overhead on top of the 'real' AI work; the loop is the design work, with the AI accelerating one step of it.

There is a quieter reason too, and it matters for your development as a designer. Every time you evaluate and refine, you are exercising exactly the judgement that makes you good - deciding what is appropriate, catching what is off, knowing why one option beats another. Outsource that step to the machine and you do not just risk a bad result; you stop practising the skill that is your whole value. Close the loop yourself and the opposite happens: the AI handles the drudgery while your judgement gets sharper with use. This is why leaning on AI as an autopilot is a trap even when it appears to work - it hollows out the designer over time - whereas using it as an amplifier, with you closing every loop, makes both the work and the person behind it better.

Closing the loop does not mean forensic verification of everything - that would be as foolish as verifying nothing. The discipline is matching your scrutiny to the stakes, so effort lands where it counts. This is the operating version of the mental model from Lesson 0.3.

On low-stakes, divergent work - a moodboard, a brainstorm list, a batch of concept sketches - a glance is enough. The worst case is a wasted idea, and being ruthless here just slows you down. Evaluate lightly, curate fast, move on.

On mid-stakes work - a client email, a research summary, a first-draft schedule - read it through properly. Fix the facts, correct the tone, make sure nothing is quietly wrong before it leaves your hands. A skim, not a forensic audit.

On high-stakes, convergent work - a code or compliance check, a specification, a structural figure, anything going to site or into a contract - verify every specific claim against its real source. Trust nothing because it reads well; the polish is not evidence. This is the work you sign, so the burden of proof is entirely yours.

The error runs in both directions. Over-scrutinising low-stakes output wastes the very time AI was meant to save; under-scrutinising high-stakes output is how a hallucinated clause ends up on a drawing. Calibrating the dial - loose here, ruthless there, in real time and almost without thinking - is the mark of a mature AI-assisted designer.

A practical way to build the instinct is to ask one question before accepting any output: what happens if this is wrong and I do not catch it? If the answer is 'a slightly worse moodboard', wave it through. If the answer is 'a non-compliant stair reaches a contractor with my name on it', you know exactly how much checking it deserves. The stakes are a property of the task and its consequences, not of how confident or polished the AI sounds - and confidence is precisely the misleading signal, because high-stakes hallucinations arrive looking just as assured as trivial ones. Reading the consequence, not the tone, is what lets you spend your scrutiny where it actually protects you and your client.

A few habits turn the loop from a slogan into a reliable practice.

Iterate in small, deliberate turns. Change one thing per round - a constraint, an example, the format - so you learn what actually moved the output. A tightening sequence often looks like this:

Round 1  broad: "8 concepts for a courtyard house in a hot-dry climate"
Round 2  add a constraint: "...now push the three that use the courtyard
         for stack ventilation; drop the rest"
Round 3  refine one: "develop option 2 - narrow plan, deep verandah;
         list its three biggest design risks so I can judge it"

Each round you direct more sharply because you evaluated the last one. That is the loop compounding.

Make output easier to evaluate. Ask for the reasoning, the sources, the assumptions, or a list of risks - not because you trust them blindly, but because they give you handholds to judge. A prompt ending 'list what you are unsure about' surfaces exactly where to look.

Guard the loop hardest where it is easiest to lose - automation. When you chain tools or use an agent (Module 8), the human step gets designed out by default. Deliberately put a checkpoint back in at the high-stakes points, so the pipeline pauses for your judgement rather than shipping unreviewed. The more automated the workflow, the more intentional you must be about where you re-enter it. Get this loop into your hands and every later module becomes an application of the same four steps - which is exactly the point: one discipline, applied everywhere, with the designer always the one who closes it.