One good loaf is not a bakery.
A good AI output proves the model can do it. An evaluation tells you whether you can rely on it.

- Next Token Prediction
- Evals
- AI Governance
- Production AI
· Dr Lara Okunuga · 6 MIN
Imagine you’re making bread at home. You find a recipe, put the ingredients together, use your oven, and get a decent loaf. You eat it. Job done. Nobody is watching and nothing is riding on it. You probably don’t care whether tomorrow’s loaf is slightly taller, darker, softer or a different shape.
That’s casual prompting. You asked for something, the answer looked good, so the prompt appears to work.
A business has a different problem. It can’t sell 500 loaves on the strength of "we baked one yesterday and it looked great."
A bakery needs 500 loaves of the same shape, the same weight, the same crust, because a customer who buys a good sourdough on Monday and a brick on Tuesday doesn’t come back on Wednesday. What has changed is that inconsistency is now the enemy.
With AI you don’t have a dial-in oven and a trained baker. You have an apprentice who has never read a recipe in their life. They learned by watching millions of bakers work, and they’re brilliant, fast and cheap. But they don’t work the way you think they do.
- The apprentice
- AI MODEL
- The recipe
- PROMPT AND CONTEXT
- The product specification
- EVAL RUBRIC
- The batch
- TEST SET
- Quality control
- EVALUATION PROCESS
How LLMs work (next-token prediction)
The apprentice doesn’t have a finished answer stored somewhere to retrieve. There’s no picture of a finished sourdough in their head when they start.
At each step they look at everything that has happened so far, weigh up which next moves are plausible, and pick one. Then they do it again. One prediction at a time, until the loaf is done.
And they’re not choosing the most correct next move. They’re predicting which next pieces of text are plausible, assigning probabilities to them, and generating one of those possibilities. That’s what a language model is.
Next token
The customer would like a
- refund
- 41%
- replacement
- 27%
- response
- 12%
...
Once a token is generated, it becomes part of the context used to predict the next one.
Which explains why the same recipe on Monday and Tuesday gives you different loaves. “Most plausible” is a ranking, not a rule, and sometimes they take number two.
Longer, multi-step generations create more points where the output can diverge, especially when the task or instructions are ambiguous.
The apprentice puts the salt in twice. The next prediction is now conditioned on a dough that already has too much salt. The model can sometimes correct itself later, but it can’t erase the tokens it has already generated.
The variables that decide output quality
Developing a recipe a bakery trusts means experimenting. Different quantities, different oven settings, different processes, until the batch comes out right consistently.
The same applies to an AI system a business can rely on. And note who is turning the dials: the baker, not the apprentice. The apprentice arrived already trained. You can’t change how they think. Everything you control sits around them.
| Variable | In a chat interface | In a built system |
|---|---|---|
| Model choice | Pick from a dropdown, swapped out by the provider whenever | Pinned to a specific version |
| Prompt | Retyped, tweaked, half remembered | Versioned and identical between runs |
| System instructions | Partly, via custom instructions or projects | Explicit and complete |
| Examples | Pasted in when you remember | Structured and consistent |
| Temperature | Not available | Set and locked |
| Reasoning effort | Sometimes | Yes |
| Output format | You ask nicely | Enforced and validated |
| Context supplied | Whatever you happened to paste | Retrieved deliberately, same source every time |
| Amount of context | Grows invisibly as you chat | Bounded and controlled |
| Tool access | Whatever is toggled on | Scoped and logged |
| Conversation history | Accumulates and contaminates | Reset per run, or deliberately managed |
That’s the problem with building in a chat interface. You’re baking in somebody else’s kitchen. Some of the dials are missing, the rest were pre-set by someone who has never seen your product, and the settings quietly shift while you work.
The issue isn’t only that you can’t tune these in a chat window. It’s that you can’t hold them still. Every message you send changes the conditions of the next one.
Which makes controlled, repeatable testing much harder. And if you can’t reliably reproduce the conditions of a test, it’s difficult to know whether performance actually improved.
That’s the real cost of building your business process in a chat window. Not that the output is worse. It’s that you can never prove it’s good.
Why evaluation matters
The bakery producing 500 loaves of the same shape, weight and crust needs a process that repeatedly produces bread within acceptable standards.
A bad loaf is easy to spot. Underbaked, burnt, collapsed, wrong shape. You can see it from across the room.
A bad loaf usually tells you it’s bad.
A bad AI answer can be fluent, confident and beautifully formatted.
You can’t open the apprentice’s head. You can ask it to explain its answer, but whatever it tells you is itself just the most plausible sounding explanation.
So you’re left with one option: taste the bread. Systematically. Against a standard you wrote down before it was baked. That’s an eval. Not a vibe check.
| In the bakery | In an AI system |
|---|---|
| The reference loaf you keep in the back to compare against | Golden dataset. Known inputs, known good outputs |
| Spec sheet: 800g, 22 min, this crust colour, this crumb | Scoring rubric, written before the batch, not after |
| Coverage: every order you will actually get. Humid day, new sack of flour, Saturday rush, gluten free request | Realistic range of inputs. Ambiguous request, angry customer, missing information, adversarial prompt |
| Reliability: same recipe, same conditions, twenty loaves. Are they actually the same? | Same input, many runs. One good output proves nothing |
| Tweak the recipe for a better crumb, re-test the whole spec | Regression suite. Fixing one thing breaks another |
| Flour supplier changed the blend without telling you | The model got updated. Your prompt silently drifts |
| Refunds, complaints, one-star reviews | Production monitoring |
Two loops, one gate
One loop gets the recipe right. The other keeps it right. Nothing crosses into production without passing the spec, and drift throws you straight back.
The evaluation loop
Set once
01Define good
Write the spec down before anything is built
02Build a test set
Real inputs, known good outputs, including the ones you dread
↓ then, and only then
Build loop
- 03
Run the batch
consistency + coverage
- 04
Score it
against the rubric, not against your gut
- 05
Change one thing
then re-run the whole set
Passes the spec
Y ↓ production · N ↑ back round
Production loop
- ·
Goes live
- 06
Watch it
named owner, real cadence
- ·
Drift detected
model update, new defaults
The gate swings both ways. A model update, a new provider default or a shift in how customers write can move the output without anyone touching the recipe. When that happens you don’t patch production, you go back round the left loop.
Five things to ask whoever is building your AI system
- 01
What does “good” look like, written down?
- 02
Show me the batch, not the loaf.
- 03
What does failure look like when it doesn’t look like failure?
- 04
Who tastes the bread once it’s live, and how often?
- 05
When the flour supplier changes the blend, how do we find out?
If you already have AI running in your business and you can’t answer these five, that isn’t a failure. It’s just the audit you haven’t done yet.
Free · 30 minutes · No pitch
