Lesson 7 ended on a promise: if a stray pick can tip a whole sentence, then what you type — before any of that happens — matters enormously. This lesson turns that into technique. None of it is a trick. It's all just tilting the board on purpose.
Go all the way back to the square board. Five slots, one floor — and it was you who chose where to pour. Pour at slot 2, the pile formed under 2. Pour at slot 5, it formed under 5. The model never picked that; you did.
A prompt is just a much richer version of the same choice. Every word you type before you hit send is part of where you're pouring — and the whole floor responds to it before the model ever starts leaning toward an answer.
Here's the practical version of what Lesson 7 warned about. A vague prompt leaves the floor's warm patches spread thin across many roughly-equal bins — exactly the near-tie condition where a stray pick is likeliest. A specific prompt concentrates the warmth into one clear channel.
Neither model is broken. The specific one just gave the floor far less room to be uncertain in.
Training paints the floor once, for everyone. But you can hand the model context — background, examples, a role to take on — right there in your prompt, and it warms the relevant patches just for that one pour.
Paste in the document you're actually asking about. Show it one example of the style you want. Tell it to answer as a specific kind of expert. None of that retrains anything — Lesson 2's frozen floor is still frozen — but it gives this one pass a much narrower, better-informed channel to fall into, the same way a detailed question did in the figure above.
Remember the loop from Lesson 3: every pass is one small, confident pick, fed back in for the next. A long, careful answer isn't one giant leap of insight — it's many small ones, each fairly safe on its own.
Asking it to "think step by step," or to lay out its reasoning before giving a final answer, is a real technique with a name: chain-of-thought prompting. It works because it forces more, smaller loop passes instead of one big one — and a small confident step is far less likely to be a stray pick than a single leap straight to the answer.
If the first pile isn't the one you wanted, you're not fighting the model — you're just choosing a better slot. Rephrase, add the detail you left out, try a different angle.
This is the same reassurance from Lesson 1, put to use: it doesn't change as you use it, and it isn't quietly getting annoyed at your third attempt. Each pour is independent. A better prompt this time doesn't need to undo anything from last time — there's nothing to undo.
The model itself keeps nothing between messages. No memory, no notes, nothing warm left over from your last question. Every pour is a fresh one — Lesson 3's loop starts over from nothing, every single time.
So how does a back-and-forth conversation work at all? Your chat interface is doing the remembering for it. Every time you hit send, it quietly gathers up the whole exchange so far — everything you've said, everything it's said back — and pours that entire transcript in again as fresh context for this one message. That's the same "context" from a moment ago, just handed over automatically instead of typed by hand. Take the transcript away, and the model wouldn't know a conversation had ever happened.
That's also the ceiling on how personal this can feel: the memory only exists inside that one growing transcript, gone the moment it ends. Curious how a platform gives an assistant memory that actually persists across conversations?
That growing cost is exactly the kind of problem worth solving at the platform level, not one prompt at a time. See how orqo manages it.
There's a real ceiling here. No phrasing, however careful, changes what the model fundamentally does.
The best prompt in the world still can't make it count letters it never saw one at a time, or know something after its training ended, or turn a genuinely thin, thinly-covered topic into a well-painted one. Good prompting narrows the lean within what the model actually knows. It doesn't hand it knowledge it never had.
Everything so far has happened inside a chat window — ChatGPT, Claude, or something built to look like them. That window is a product, not the model itself.
The next lesson shows the other door: the same model, reachable directly, priced by the token — and how a business builds its own product on the exact same intelligence.
Everything from the lessons before this one, plus what this lesson added.
| The board | The word for it |
|---|---|
| The board and its pegs | The structure — the model |
| A single peg | A neuron |
| A single step from one peg to the next | A connection |
| How red or blue a patch of floor is | A weight — a parameter |
| The whole painted floor | The trained model |
| Boards stacked, one on the next | Layers — "deep" |
| Smearing the floor in, coin by coin | Training |
| Dropping one coin through a finished board | Using it — inference |
| Which slot you pour into | Your input — your prompt |
| The bins, relabelled with tokens | The vocabulary — every token it could pick |
| The tallest pile among the bins | The prediction — the likeliest next token |
| Feeding the growing line back in and running again | The loop — how one guess becomes a sentence |
| One bin's label, precisely | A token — not always a whole word |
| How many bins there are, in total | Vocabulary size — tens of thousands |
| The size of the mountain of text it was shown | Training data — measured in tokens |
| A bin's own address, plotted in space | An embedding — meaning turned into a list of numbers |
| How close two addresses sit | Similarity — how related two things are |
| The measurement's real name, out in the wild | Cosine similarity — same idea as similarity, different name |
| About meaning, not exact spelling | Semantic |
| A neighbourhood of addresses that share a topic | A domain — a cluster of related meaning |
| Scanning every address for whichever one sits closest to a new point | Nearest neighbor — the closest real match to a computed point |
| A small, separate machine that only plots words as points — it never writes a sentence | An embedding model — not the same as a language model |
| The total number of coloured patches, across every board | Parameters — the number people quote |
| How many tokens the funnel can hold in one pour | Input tokens — the context window |
| How many tokens come back out | Output tokens — what it writes back |
| Everything you've met so far, built at real-world size | A Large Language Model — an LLM |
| A shorter pile winning, extended forward with full confidence | A hallucination |
| The point where the training reading stopped | The knowledge cutoff |
| How sharp or blended the colour stays before a coin is poured | Temperature — the dial on how often a stray pick wins |
| Pouring the same slot twice, not always the same pile | Non-deterministic — same input, no guaranteed identical output |
| + New in this lesson | |
| Background, examples, or a role, added right into the pour | Context |
| Asking for many small steps instead of one big leap | Chain-of-thought prompting |
32 rows now. It keeps growing as the course goes on.