Ask ChatGPT, Claude, or Gemini how many times the letter 'r' appears in the word 'strawberry,' and you will likely receive a confident, incorrect answer. This is not a bug that engineers are racing to fix. It is a window into the fundamental architecture of the most powerful AI systems ever built — and a reminder that these tools, for all their fluency, do not think the way we do.
The strawberry problem, which became a minor internet sensation when users began cataloguing such failures, demonstrates that large language models process language in ways that are simultaneously more sophisticated and more primitive than human cognition. Understanding why reveals both the genuine marvel of what these systems accomplish and the hard ceiling on what they can achieve without architectural reinvention.
The tokenization problem
When you type a word, you see letters. When a language model receives that same word, it sees something else entirely: tokens, which are chunks of text that the model has learned to treat as atomic units. The word 'strawberry' might be processed as 'straw' + 'berry' or 'str' + 'aw' + 'berry,' depending on the specific tokenization scheme. The model never sees the individual letters at all — it has no direct access to the orthographic structure of words.
This is not an oversight. Tokenization makes language models computationally tractable. Processing text character-by-character would be prohibitively expensive and would actually harm performance on the tasks these models excel at: understanding context, generating coherent prose, answering questions about complex topics. The tradeoff is that certain operations humans find trivial — counting letters, identifying rhymes, detecting palindromes — become genuinely difficult or impossible.
Pattern matching all the way down
The deeper issue is that language models do not manipulate symbols the way a calculator manipulates numbers. They predict probable continuations based on statistical patterns learned from training data. When asked about letter counts, the model is not counting; it is recalling patterns from similar questions it encountered during training and generating a plausible-sounding response.
This explains why these systems can write passable poetry but struggle to verify whether their poems actually rhyme, why they can discuss mathematics eloquently while making elementary arithmetic errors, and why they can explain the rules of a game without being able to play it competently. The appearance of understanding emerges from pattern completion, not from the kind of structured symbolic reasoning that would let a system reliably verify its own outputs.
What this means for users
None of this diminishes the genuine utility of large language models. They remain extraordinary tools for drafting, brainstorming, summarizing, translating, and exploring ideas. But the strawberry problem is a useful heuristic: any task that requires precise symbolic manipulation, exact counting, or step-by-step logical verification should be approached with skepticism. The model may produce a confident answer that is simply wrong, and it will not know the difference.
The companies building these systems are aware of the limitations and have developed workarounds — allowing models to call external tools for arithmetic, for instance, or training them to show their reasoning step-by-step. These patches help, but they are patches. The underlying architecture remains a prediction engine, not a reasoning engine.
Our take
The strawberry problem is not an embarrassing failure to be minimized; it is an invitation to understand what we have actually built. Large language models are the most impressive pattern-matching systems ever created, capable of feats that seemed like science fiction a decade ago. They are also, in a fundamental sense, not intelligent in the way humans are intelligent. Recognizing this distinction is not pessimism — it is the precondition for using these tools wisely and for understanding what genuine progress toward artificial general intelligence would require.
