Why AI Sometimes Can't Count Letters in a Word

Imagine asking one of the most advanced AI systems ever built a question that a six-year-old could answer:

Sometimes the AI answers correctly. Sometimes it confidently says two. Sometimes three. Occasionally it changes its answer after being corrected, only to make a different mistake the next time.

How can a model capable of writing software, explaining quantum mechanics, and translating dozens of languages struggle with something as simple as counting letters?

At first glance, this feels like a bug. In reality, it exposes one of the most important — and least understood — parts of modern AI systems. The answer has very little to do with intelligence. Instead, it begins with a design choice hidden deep inside every large language model: they don't actually read text the way humans do.

1. Before AI Reads Anything

Humans naturally see words as collections of letters. When you read strawberry, your brain simultaneously recognizes the entire word, each individual letter, repeated letters, pronunciation, and spelling — all at once, without conscious effort.

Modern language models don't work this way. Before a model performs any reasoning, every sentence passes through an invisible preprocessing stage called tokenization. The tokenizer converts text into numerical pieces called tokens. Those tokens — not the original characters — become the model's actual input. This distinction changes everything downstream.

2. A Word Isn't Always One Piece

People often imagine that words become individual tokens. Sometimes they do. Often they don't. For example, a tokenizer might split understanding into something resembling:

Another word might remain whole. Another may split into four fragments. There's no universal rule — the tokenizer simply tries to reuse pieces it learned to be efficient with during training. This optimization dramatically reduces vocabulary size and training cost, but introduces a surprising consequence: the model begins reasoning about pieces of words, not necessarily the words — or letters — themselves.

3. Meet Byte Pair Encoding

One of the most influential tokenization algorithms is Byte Pair Encoding (BPE). Despite the intimidating name, the idea is surprisingly practical. Imagine reading millions of books and noticing that certain letter combinations appear constantly: ing, tion, pre, re, un.

Instead of storing every letter individually every time, you gradually merge common sequences into reusable building blocks. Eventually, t + i + o + n becomes a single token: tion, because it appears so frequently. Then under becomes another reusable token. Over millions of merges, the tokenizer builds a vocabulary of commonly occurring fragments.

The result is faster training and far fewer symbols for the model to process. For predicting language, this is incredibly efficient. For counting letters? Not so much.

4. Where the Blind Spot Appears

Suppose the tokenizer has already compressed berry into a single token. From the model's internal perspective, straw + berry may be closer to reality than s-t-r-a-w-b-e-r-r-y as ten separate characters.

Notice what disappeared: individual characters. The model is no longer "looking" at each letter separately — it's reasoning using higher-level language fragments. When asked how many "r"s are in strawberry, the model often tries to reconstruct the spelling from statistical memory instead of literally inspecting the characters. Most of the time that's good enough. Sometimes it isn't.

5. Why Isn't This Always Wrong?

Interestingly, LLMs often answer correctly. That's because they've seen countless discussions about spelling, dictionaries, programming, and language itself during training. Rather than counting letters directly, they frequently remember the correct answer.

This creates an illusion — it appears as though the model counted the letters, when in many cases it simply recalled a pattern it had learned previously. When the word is uncommon, invented, or intentionally tricky, that shortcut becomes unreliable, and the cracks show.

6. Why Humans Rarely Make This Mistake

Humans effectively have two separate abilities running in parallel: one system understands language and meaning, and another can inspect individual symbols directly. You can ignore meaning entirely and count letters one by one, switching modes at will.

Language models don't naturally separate these tasks. Their architecture was optimized to predict the next token — not to inspect characters with perfect precision. Character-level reasoning is something they learn indirectly, as a side effect of training, not something they're fundamentally built around from the ground up.

7. Could We Fix This?

Researchers have explored character-level language models that process every individual character directly. In theory, they eliminate many spelling-related blind spots. In practice, they introduce a different problem: instead of processing perhaps twenty tokens for a sentence, the model may now need to process hundreds of individual characters.

8. Common Myths

• "AI can't count." Reality: AI can perform arithmetic quite well. The difficulty specifically lies in accessing individual characters after tokenization, not in counting itself.
• "This is just a software bug." Reality: it's largely a direct consequence of how modern language models represent text internally — a design trade-off, not an accident.
• "Every AI makes the same mistakes." Reality: different models use different tokenizers, architectures, and reasoning strategies. Some are noticeably better at character-level tasks than others.

9. Practical Advice

If your task depends on exact characters rather than language meaning, don't assume an LLM is the right tool. This includes:

• Counting letters
• Checking passwords
• Validating identifiers
• Regular expressions
• Cryptographic strings
• DNA sequences
• Binary data

Traditional software remains more reliable for these tasks, because it processes symbols exactly as written, with no lossy compression step in between. LLMs excel when the task involves understanding meaning rather than inspecting raw text character-by-character.

10. The Bigger Lesson

The "AI can't count the letters in strawberry" meme isn't really about counting. It's a reminder that intelligence depends heavily on representation. Humans begin with letters and build words. Large language models often begin with tokens and infer the letters only when needed.

That invisible design decision — made long before the AI generates its first response — shapes many of the strengths and weaknesses we observe today. Once you understand tokenization, a whole class of seemingly bizarre AI behaviors suddenly makes perfect sense.