{ random memes }

The human–LLM loop

Figure 1: the human-LLM loop drawn as a ring of six steps. Human steps 1, 5 and 6 (write the prompt, read the product, correct and add) alternate with model steps 2, 3 and 4 (take the input, chain through knowledge, generate the product). The prompt library and operating system, and the model's weights, sit in the middle of the ring.
Figure 1 — one turn of the loop: six steps, numbered in the order they happen. Open the full-size file: SVG · PNG (3000×2528).

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?"

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

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

  • 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

  • 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.

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

Two stores sit in the middle of the ring, 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.