{ random memes }

The human–LLM loop

A single exchange with a language model is not a transaction. It is one turn of a cycle, and once you see the cycle the interesting question stops being "which model?" and becomes "what am I feeding the loop, and what am I doing with what comes back?"

Two entities, a human and an AI, each in a box. A thin arc labelled prompts runs from the human box to the AI box; a fat arc labelled products runs back from the AI box to the human box.
Figure 1 — two entities, one turn. Prompts go out thin; products come back thick.

Here is the whole turn, numbered in the order it happens:

Six numbered steps in order, left to right: write, take, chain, generate, read, reflect. Steps one, five and six belong to the human and sit on a light panel at the start and again at the end; steps two, three and four belong to the model and sit on a differently tinted panel between them. The arrow from write to take is labelled prompts and the arrow from generate to read is labelled products; they are the only two that cross between panels. A long arrow under the strip runs from reflect back to write.
Figure 2 — the same turn, in order. The two arrows that cross between panels are the two arcs of Figure 1, and reflect closes the loop.
Step Who What happens
1 you Write the prompt — intent, constraints, the shape of the answer, what "done" means
2 model Take the input — step 1 plus your prompt library and standing "operating system"
3 model Chain through knowledge — everything held in the weights, traversed token by token
4 model Generate the product — text, code, a plan, a decision, with the model's noise attached
5 you Read the product — appraise what came back against what you actually meant
6 you Correct and add — corrections derived from step 5 become the next step 1

Steps 2, 3 and 4 are the machine's. Steps 1, 5 and 6 are yours, and they are where everything that matters is decided.

Three of the six steps are yours

The human box from the previous figure, magnified. The box, labelled Human, is divided into a stack of write, domain knowledge, and read. The thin prompts arc leaves its right edge at the height of the write layer and runs off the right of the picture; the fat products arc enters from the right and arrives at the height of the read layer.
Figure 1.Human — the human box, magnified. What you write out of the top, what you read in at the bottom.
  • Step 1 — write the prompt. State the intent, the constraints, the shape of the answer and what "done" means. This is the only place in the loop where a goal enters; everything downstream is reaction to it.
  • Step 5 — read the product. Appraise what came back against what you actually meant. This is filtering, and it is where domain knowledge earns its keep: you cannot remove an error you cannot recognise.
  • Step 6 — correct and add. The corrections and additions derived from reading at step 5 become the next prompt at step 1. This is the arc that closes the loop, and the reason the loop has a direction rather than just going round.

What the model is doing in there

The AI box from the previous figure, magnified. The box, labelled Large Language Model (AI), is divided into a stack of model, engine, and hardware (GPU). The thin prompts arc and the fat products arc both meet its left edge at the height of the model layer, then run off the left of the picture.
Figure 1.AI — the AI box, magnified. The same two connections; the human is off to the left.
  • Step 2 — take the input. Your prompt, plus the prompt library and the standing "operating system": the conventions, definitions and preferences you reuse across projects. That library is part of the input whether or not you are deliberate about it, which is why a sloppy house style quietly shapes every answer you get.
  • Step 3 — chain through knowledge. The model traverses what is held in its weights, weighting each step against the context it was handed. It has no way to tell which part of that context was signal and which was noise.
  • Step 4 — generate the product. Text, code, a plan, a decision, with the model's own noise and distortion attached, because the same gain that produced the good parts also produced the bad ones. That is the subject of the next post.

Taken together, steps 2 to 4 are a straight line through the model: the same gain G applied to everything that enters, with the model's own noise n(t) and distortion d(t) added along the way. The gain does not vary from one user to the next; what differs is the signal entering it and the filter applied after it.

The model has no goal of its own. It amplifies whatever step 1 supplies, so the loop is only ever as good as steps 5 and 6.

What persists between turns

A ring of six numbered steps joined by arrows so the last leads back to the first: write, take, chain, generate, read, reflect. The human's three sit on a light panel down the left; the model's three on a differently tinted panel down the right. Under the ring are the two sources of judgement: domain knowledge, deeply understood, feeds the human's reflect; all human knowledge, only slightly understood, feeds the model's chain.
Figure 3 — the same six steps, closed. The two human panels have become one, and each side's judgement is shown sitting on what informs it.

Two stores persist across turns, and they are what make this a loop rather than a series of unconnected chats:

  • The prompt library and operating system — yours, and improved slowly. When a correction generalises, distilling it back into the library means the next project starts from a better step 1. This is the slow loop; the turn-by-turn cycle is the fast one.
  • The model's weights — the knowledge step 3 chains through. Fixed for your purposes: you cannot improve them per turn, you can only choose how well you address them.

Distilling is the part people skip. A correction that stays in the chat window dies there; a correction that lands in the library compounds.

The same loop, either virtuous or vicious

Virtuous cycle Vicious cycle
Step 1 precise vague
Step 5 real appraisal nothing to check against
Step 6 corrections that carry information largely more noise
Over many turns the signal grows relative to the model's noise: ‖G·H‖ < 1, so the loop converges and turns become cheaper and sharper the surviving noise is re-amplified: ‖G·H‖ > 1, so the output drifts further from anything true while sounding more confident

This is the whole reason the metaphor is worth drawing. The two cases are not "a good user" and "a bad user" of the same straight-line tool. They are the same loop with the feedback gain on opposite sides of one, which is why the failure mode is not a merely weaker version of the success mode, but its mirror image.

Running the loop well

  • Make step 1 checkable. If you cannot say what would make the answer wrong, step 5 has nothing to work with and the loop is open.
  • Treat step 5 as the real work. Reading well is the expensive part; generating is now cheap.
  • Keep step 6 honest. Write down the correction, not just the new prompt; a correction you cannot state is one you cannot reuse.
  • Distil into the library. Anything that generalises should not have to be re-derived next turn.
  • Know which domain you are in. In your own field you are a strong mind and the loop converges; outside it you are a weak mind and the loop will happily compound noise.

The next post opens up step 4: what the model's gain actually does to the signal, and why the same model is a force multiplier for one user and a noise multiplier for another — An LLM is an amplifier.