Why AI image models still can't spell

Image models build the whole picture at once, aiming for what looks plausible, and a plausible-looking letter isn't the right letter. Most also read your prompt as tokens rather than characters, so a word arrives as meaning without its spelling. Long headlines, small type, busy backgrounds and non-Latin scripts fail most often.

Generate an ad with any image model and you'll eventually get something like "SUMER SLAE — 40% OFF" in beautiful kerning on a beautifully lit product shot. The lighting is right. The composition is right. The headline is gibberish.

This is the single most annoying failure mode in AI ad creative, and the explanations you find online are mostly wrong. It's not that the models "weren't trained on enough text." It's structural.

Diffusion models don't know what a letter is

An image model doesn't build a picture the way a designer does — place a text layer, set the string, render the glyphs. It starts from noise and denoises toward something that matches your prompt, all at once, across the whole canvas.

For most of the image, that works brilliantly, because most of the image is statistical. A plausible shadow is a good shadow. A plausible fold in fabric is a good fold. Nobody can tell you the shadow is wrong, because there is no single correct shadow.

Text is the opposite. There is exactly one correct arrangement of pixels for the word "SUMMER," and every other arrangement — including the ones that look like confident, well-formed letterforms — is wrong. The model is optimising for plausibility, and a plausible-looking letter is not the same thing as the right letter.

The model isn't spelling badly. It's not spelling at all. It's drawing shapes that look like the kind of shapes that appear where text appears.

Tokenization makes it worse

Most of these models receive your prompt through a text encoder that works in tokens, not characters. "SUMMER" may arrive as one or two tokens — an opaque chunk that carries meaning, not a sequence of six letters.

So the model has a rich sense of what summer means: warmth, light, a season, a certain palette. What it does not reliably have is the information that this concept is spelled S-U-M-M-E-R. You are asking a system that thinks in concepts to reproduce an exact character sequence it was never cleanly given.

Longer strings compound the problem. Every extra word is another chance to drift, and there's no mechanism forcing consistency between the start and end of a headline — they're being denoised in parallel, not read left to right.

It has genuinely got better, and that's a trap

Newer models are dramatically better at this. Short strings in clean type on a plain background now land most of the time. That improvement is real, and it's also the reason this problem now costs people more than it used to.

When a model failed at text 90% of the time, you checked every render. When it fails 10% of the time, you stop checking — and the one broken headline goes out in a campaign, gets impressions, and burns budget before anyone notices. A failure mode that's rare but unmonitored is worse than one that's common and obvious.

The difficulty also isn't uniform. Roughly in order of how often things go wrong:

Harder	Easier
Long headlines (6+ words)	Short headlines (1–3 words)
Small type, dense layouts	Large type, generous space
Text over busy imagery	Text on flat backgrounds
Stylised / script / condensed faces	Plain sans-serif
Non-Latin scripts, accented characters	Unaccented Latin
Multiple text blocks	A single block

None of this is a reason to avoid generating text in ads. It's a reason not to trust it.

How do you get correct text in AI-generated ads?

Three approaches, in increasing order of how much I'd rely on them.

Prompt harder. Quoting the exact string, asking for a specific typeface, requesting generous spacing. This helps a little. It is not a fix — you're still asking the same system to do the same thing it's structurally bad at, and you find out whether it worked by looking.

Composite the text yourself. Generate the imagery, then draw real text on top with a real text renderer. The spelling is then perfect by construction, because a font renderer drew it. The cost is that the text stops being part of the image — it sits on top, and it looks like it. For a lot of display formats that's completely fine. For anything where type is integrated into the scene, it looks pasted on.

Keep the integrated output, but gate it. Let the model draw the whole ad, then refuse to let anything reach an ad account until the words on the image have actually been read. Most teams do this with a person and a checklist, which works fine — right up to the volume where it becomes the bottleneck, and where a rare failure is exactly the one nobody catches.

Only the third keeps the type sitting in the image rather than on top of it, which is why it's the one worth the effort. It's also the one we've put the most work into at Terrads: you get the integrated look without doing the proofreading yourself.

The practical version

If you take nothing else from this:

1. Keep headlines short. Every word is a new opportunity to fail.
2. Read every headline before it goes live. Character by character, not at a glance — the failure you're looking for is one wrong letter.
3. Be suspicious of confident-looking type. The failures look good. That's exactly what makes them dangerous.
4. Treat non-Latin text as unsolved. If you're localising, check every locale individually, every time.

The models will keep improving at this, and at some point checking stops being worth the bother. That point is not now.

Sources

• Character-Aware Models Improve Visual Text Rendering — Liu et al., arXiv 2212.10562: popular text-to-image models lack character-level input features, and character-aware text encoders spell markedly better (accessed 2026-09-15)

---

Related: what Meta's AI disclosure rules actually require — less than you've probably been told.

Building ads with AI and tired of proofreading every render? Try Terrads — it checks the text for you.