Our own plain-English AI vocabulary opens with a heading that reads "Start here: the model on its own can only write." It is a good sentence and it has been sitting there unfinished, because it raises a question the guide never comes back to: if the model can only write, what is the thing making the pictures?

It is not the same kind of thing, and almost every complaint people have about generated images follows from that one difference. The spelling. The hands. The reason a Chinese character in a poster comes out as something that looks like a character but is not one. None of those are bugs anyone forgot to fix. They are what you get from a machine that was never emitting letters in the first place.

What kind of claim each thing here is

We use three registers in this guide. A mechanism is the standard published account of how these models work — how diffusion and the flow-matching models that followed it differ from a text model. We did not measure it; it is the consensus description.

A measurement is something we counted in our own catalogue, logs or tool code, shown so you can redo it.

An observation is something we saw once while running a model ourselves. One observation is not evidence of a general property, and where this guide leans on one it says so.

What we could not do: we did not run a controlled experiment on spelling or anatomy for this guide. We have run one image model end to end — Stable Diffusion 1.5 on a CPU, published last month — and one speech model, whisper.cpp. That is a narrow base, and it is why the mechanism sections below are labelled as the standard account rather than as our findings. A guide claiming to have proved why hands come out wrong, off two runs, would be doing the thing this series exists to avoid.

One token at a time, versus the whole canvas at once

Here is the difference everything else follows from.

A language model emits one token at a time. It picks a token, appends it, looks at everything so far, and picks the next. The output is a sequence, built left to right, and every piece of it is a discrete symbol drawn from a fixed vocabulary. Our guide on tokens and context windows takes that apart properly.

An image model does almost the opposite. It starts with a canvas of pure noise and refines the entire canvas at once, over a few dozen passes, nudging every region toward something that looks more like the prompt and less like static. There is no first pixel and no last pixel. There is no sequence. There are no symbols — just a continuous field of values that gets less random each pass.

That is the core distinction, and the whole guide rests on it. A text model works sequentially, with discrete symbols. An image model works holistically, with continuous values.

That is why "prompt engineering" means such different things on the two sides. On the text side you are steering what comes next. On the image side you are steering a whole picture's worth of simultaneous decisions, which is why the controls are so odd — weights on individual words, negative prompts describing what you do not want, a seed that fixes the starting noise so you can change one thing and keep the rest. Our own prompt weight editor and seed generator exist because of this; nothing equivalent is needed for a chat prompt.

Why it cannot spell

Now the payoff.

A text model has letters. Not always whole ones — our tokens guide shows a rare Chinese character being split into unprintable pieces of its own byte encoding, two fragments per character, under the heading "What happens when a character is too rare". But even a fragment is a discrete symbol the model can emit. Spelling, for a text model, is selection from a vocabulary.

An image model has none of that. It has never emitted a letter, because it does not emit symbols at all. What it has learned is that a certain arrangement of light and dark tends to appear in pictures of shop signs. It is painting the texture of writing. There is no step in the process at which anything is spelled, so there is nothing to spell correctly.

This is the real story behind "AI can't do text in images". The model is not bad at spelling; it simply does not perform the operation of spelling at all.

Which sets up the part that matters most to readers here. If letters are shapes the model imitates, then the scripts it imitates worst are the ones with the most shape to get wrong. A Latin letter is a handful of strokes from an alphabet of twenty-six. A Chinese character is a structured arrangement of components, thousands of them, where a single stroke is the difference between one word and another. Thai stacks marks above and below a base. Jawi joins its letters and changes their form by position. A model imitating texture will produce something with the rhythm of Chinese and none of its content — characters that a reader recognises as almost-characters, which is a stranger failure than gibberish.

⚠️ One boundary worth drawing carefully, because we have published a guide that sounds like this one and is not. AI in your own language measured that non-English text costs more and fills your context faster, and the cause there is the tokeniser — how text is chopped before a language model ever sees it. The cause here is different: an image model has no tokeniser for glyphs and no glyphs either. Same-sounding conclusion, unrelated mechanism. Do not merge them.

And a caution on the fix. Vendors sell text rendering as a feature, and our five-way image model comparison looked at those claims and deliberately refused to rank them, because no independent benchmark in its sources settled it. That refusal still stands. Structurally, the tools that handle text well usually add machinery around the image model, like layout controls or a separate text-rendering pass. They are not teaching the image model to spell. It is a workaround, and a good one, and it is not the same as the problem going away.

Why hands come out wrong

Same root, different branch. The model is optimising for local plausibility — does this patch look like a plausible continuation of its neighbours — with no separate step that checks global facts about the world. Nothing in the process counts fingers, because nothing in the process knows that fingers are countable. A hand with six fingers is locally perfect everywhere; each finger looks like a finger, each joint like a joint. The error is visible only at the whole-hand level, and that kind of global accounting is exactly what a texture-matching process struggles with.

Our own guide on why AI makes things up already named the text-side twin of this, under the heading "The shape is right; only the existence is wrong". A fabricated citation has a plausible author, a plausible journal, a plausible year, and does not exist. A six-fingered hand is the same failure wearing a different coat. Both models are producing the shape of the right answer.

Our one observation, and its limits. When we ran Stable Diffusion 1.5 on a CPU and asked it for Singapore's Merlion, it returned a convincing Marina Bay skyline with the ArtScience Museum's lotus sitting where the Merlion should be. The runbook recorded that and drew no conclusion from it. The result fits the account above. Its composition is globally coherent and locally plausible, yet the one element requiring a specific fact is wrong. Still, this is a single generation from a small, old model, so we are not inflating it into evidence. It is an illustration, not a result.

Voice, which is two different problems

"AI voice" covers two things that have almost nothing in common, and conflating them causes real confusion.

Speech to text is the mature, boring, useful one. We have run it: whisper.cpp transcribed 7.3 seconds of speech in about 1.25 seconds of CPU time, and the honest detail from that run is that the small English model garbled exactly the proper nouns — a Singaporean name and "Merlion" both came back mangled — while handling ordinary words cleanly. Rare, specific, name-shaped things are hard for the same reason they are hard everywhere in this field.

Text to speech, and voice cloning, are the other one, and they carry a problem the rest of this guide does not. A generated image of a person is nobody — that is the reasoning behind our own policy allowing synthetic faces, which we set out below. A cloned voice is somebody. It is a specific living person's, it is recognisable to people who know them, and a convincing thirty seconds of it can be built from material they published for other reasons. Whatever your position on generated imagery, voice cloning is a consent question before it is a technology question, and the consent has to come from the person whose voice it is.

We have not built or run a TTS system, so this section is the shortest in the guide and stays that way. We are recording it as a gap rather than filling it with commentary.

Generate, or use stock? What our own policy actually says

Here we can speak from operating experience. We publish images every week, and our rules are written down and enforced by scripts, not by good intentions.

Our standing policy is stock first. The image engine searches two providers, self-hosts what it finds so we never hot-link, and captures the photographer's attribution automatically. Generation is the fallback, and the script that generates refuses to run unless you pass a reason — which is written to a log, so the decision stays auditable after the fact.

Three tests every image must pass, from the style lock: no fabrication, properly credited, no harm. On top of that, some deliberate mechanical guards: the generator never sees a proper noun — you pass a concept, and entity names are rejected before the call; brand, logo and trademark are hard-blocked words; and generating and publishing are separate commands, because the check in between is a human looking at the actual picture. The publish step refuses to run on a file nobody has looked at.

On synthetic faces our position is permissive and we will state it plainly rather than hedge: photorealism, people and faces are allowed, on the reasoning that a generated face is nobody and there is no likeness to infringe. What stops a misleading image is the no-fabrication test and the human eye, not a ban on realism. Reasonable people land elsewhere on this; that is where we landed and why.

What auditing our own practice found — including against ourselves

We counted, rather than assuming we follow our own policy.

Across the logged period, 42 stock heroes shipped against 27 generated ones. So stock does lead, roughly three to two. The policy is real, not aspirational.

Two findings cut the other way, and they are the useful ones.

The generate step ran 49 times and shipped 27 images. Nearly half of everything generated was looked at and thrown away. That is the human vision gate doing its job, and it is an argument for keeping generation and publishing as two commands rather than one.

But only 15 of those 49 runs gave a reason that cites the measurable threshold the policy defines. The engine scores every candidate for relevance and the policy says stock has "genuinely failed" below 0.45 — a number, deliberately, so the decision is not a vibe. Most recorded reasons are prose judgement instead ("wrong register", "returns generic office imagery"), and six are not about a story at all — art-direction tests. The guardrail we actually have is a reason was written down, which is weaker than the threshold we designed. We are recording that rather than quietly tightening it, because the fix is a policy decision and not a session's call.

One more, from today, because it is the clearest illustration of why a score is not judgement. Searching stock for a budgeting concept, the highest-scoring candidate came back at 0.98 — far above the floor — and it was a photograph of a potato balanced on a spoon against a pile of coins on a calculator. Perfectly relevant by keyword, unusable by eye. The floor tells you when to stop trying stock. It does not tell you the picture is any good.

What auditing our own tools found

We keep a substantial cluster of generation-side tools, and we audited them for this guide. As usual the honest result is mostly clean, and the clean results are reported as results.

Five tools passed examination. Our prompt weight editor correctly emits syntax for the AUTOMATIC1111 family and never claims Midjourney, which uses a different weighting notation entirely and would not read it. The Chinese negative-prompt builder properly distinguishes Stable Diffusion's dedicated negative-prompt field from Midjourney's --no parameter, rather than implying one string works everywhere. The seed generator draws full-range 32-bit values from the browser's cryptographic source with no modulo and no rejection step — notably without the sampling bug we found in two sibling randomness tools last week. The Midjourney prompt builder is current, and the aspect-ratio tool computes its ratios at runtime to avoid drift.

One defect, and the tool that computes found it. Our resolution picker hard-codes a ratio label beside each resolution, and four of the Flux entries carried the ratio the size approximates rather than the one it has. 1344×768 was labelled 16:9. It is 7:4 — 1.750 against 1.778. 1216×832 was labelled 3:2; it is 19:13, out by 2.6%.

It was caught because the file contradicted itself: the SDXL section labels that same 1344×768 as 7:4, correctly. One file, one pair of numbers, two different labels — which is what makes it an error rather than a shorthand somebody chose. The Midjourney rows are deliberately not counted as wrong, because there the label names the flag you type (--ar 3:2) and Midjourney does its own rounding; describing your intent is honest. Flux has no such flag, so its labels are claims about pixels and nothing else.

The consequence is small but definite: generate at the row marked 16:9 for a video thumbnail, and the result will need cropping. Fixed by telling the truth about the near-misses and adding exact-ratio options — 1280×720 and 1248×832, both sides divisible by 16 — for output that has to land in a 16:9 frame or a 3:2 print without loss.

These resolution buckets are not arbitrary, incidentally, and that ties back to the mechanism. Models are trained at particular sizes, and straying off those sizes degrades the picture in characteristic ways — the tool's own note for Stable Diffusion 1.5 warns that pushing past about 768 pixels on one side invites repeated heads and bodies. A model with no global structure check, asked to fill a canvas larger than anything it was trained on, fills the extra space with more of what it knows.

The gap in the catalogue, which is a finding about us

Counting the cluster surfaced something we had not looked at directly. Of 23 live generation-side tools, 16 are built for the Chinese market — roughly 70%. All seven video tools are Chinese-market: we have prompt builders for Kling, Hailuo, Vidu and Seedance and none for any Western video model. And there is exactly one audio tool on the entire platform.

Set that against our own AI directory, which lists 125 image-generation products and 155 under video and audio. So the directory says this half of the field is enormous and broadly distributed, and our tooling covers one region's slice of it plus a single music tool. This is not a defect in any one tool, but a shape to our catalogue that we did not choose deliberately. Naming it is more useful than not noticing.

What to take away

Image and voice models are not just language models with a different output. They work in continuous values, not discrete symbols, and all at once rather than in sequence. That single fact explains the spelling, the hands and the almost-characters. Knowing it changes what you ask for: you stop expecting the model to spell, you check anything that has to be counted, and you reach for layout tooling rather than a better prompt when the picture needs real words in it.

And on the ethics, the version we actually operate: try stock first, keep the reason when you do not, look at the picture with your own eyes before it goes out, and treat a cloned voice as a person's rather than a product's. We fall short of our own threshold on the second of those about two-thirds of the time, which is why it is written here rather than in a policy nobody reads.