Victor Ribeiro shipped Wordit to Hacker News on Thursday — a game where you start with a four-letter word and keep going, changing one letter at a time. Bear to beer to peer. Each correct word scores a point. Three wrong guesses and you lose.
The Hacker News thread is full of the usual feedback: the mobile keyboard is annoying, some starting words are traps, “LARP” isn’t in the dictionary. Ribeiro, recovering from his first general anesthesia, says he prototyped it in a day and plans to add harder modes with five- or six-letter words.
But buried in this tiny game is a structure that matters deeply to anyone building or studying language models. Wordit is an accidental visualization of the edit-distance graph that underlies how modern AI represents meaning.
The Graph You Didn’t Know You Were Walking
Every time you type a word in Wordit, you are walking the edges of a giant graph. The nodes are all the four-letter words in Ribeiro’s dictionary. Two nodes share an edge if they differ by exactly one letter. The game is a depth-first search through this graph, constrained by your vocabulary and your three lives.
This is not an abstract curiosity. The same graph structure — the Hamming-distance neighborhood of words — is what transformer models exploit when they learn semantic relationships. Word embeddings place “bear” and “beer” close together not because they taste similar but because they share three out of four characters and often appear in similar contexts. The Wordit graph is a sparse, hard-coded version of the continuous vector spaces that models like GPT-4 and Claude navigate.
The game’s difficulty comes from the graph’s topology. Some nodes have high degree — “time” connects to “tile”, “tide”, “time”, “timed”, “tame”, “tome”, and dozens more. Other nodes are near-isolated, connected to nothing but one or two dead ends. The commenter who got “bapt” as a starting word was stuck because “bapt” sits at a leaf of the graph: no single-letter change produces a valid English word. The game becomes a test of how well you know the graph’s connectivity, not just your vocabulary.
What This Teaches Us About AI Reasoning
The commenter tty456 noticed the game gets repetitive once you find a high-degree node. “Word like ‘time’ yielded many new *ime words.” This is the same failure mode that plagues many language-model benchmarks. When a model finds a local maximum — a cluster of similar outputs that all score well — it stops exploring. It settles.
Wordit, unintentionally, simulates the exploration-exploitation tradeoff that every reinforcement learning system faces. The three lives are your exploration budget. The high-degree nodes are your exploitation traps. Ribeiro’s proposed fix — forcing the changed letter position to rotate — is the same mechanism that curriculum learning and entropy bonuses use to force models out of local optima.
The game also reveals something about the brittleness of dictionary-based systems. “LARP wasn’t in the dictionary,” one commenter complained. Ribeiro used “the biggest dictionary I could find,” but any fixed dictionary is a closed world. The same problem haunts every rule-based NLP system from the 1990s: out-of-vocabulary words break the graph. Modern language models solve this by operating in continuous space, where “LARP” can be approximated by its subword tokens and its vector proximity to “roleplay” and “fantasy”. But the tradeoff is that they lose the crisp, enumerable structure that makes Wordit so satisfying to play.
The Deeper Pattern: Combinatorial Search as Intelligence
What makes Wordit interesting for AI builders is not the game itself but what it reveals about the nature of language understanding. The game is a pure combinatorial search problem constrained by a discrete lexicon. It is exactly the kind of problem that symbolic AI was good at and that neural networks struggle with — and that hybrid systems are now learning to bridge.
Every transformer model, under the hood, is computing something very similar to Wordit’s graph traversal. The attention mechanism computes a weighted sum over token positions, effectively asking “which of these tokens is closest in meaning to the one I am predicting?” The difference is that the distances are learned, continuous, and high-dimensional. Wordit’s graph is binary: either two words differ by one letter or they don’t. The model’s graph is probabilistic: “bear” and “beer” might be 0.7 cosine similarity apart.
The recent trend in language model research — from Anthropic’s interpretability work to OpenAI’s sparse autoencoders — is about making the continuous graph more like Wordit’s discrete graph. Researchers want to find the features that actually matter, the edges that actually connect, rather than the smooth, interpolated space that models currently navigate. Wordit is a reminder that the discrete structure was always there, hiding under the continuous approximation.
What to Watch
Ribeiro’s plan to add five- and six-letter modes is not just a difficulty slider. Each additional letter exponentially expands the graph. Four-letter words in English number around 5,000. Five-letter words are closer to 15,000. Six-letter words exceed 30,000. The graph becomes sparser, the paths longer, the dead ends more punishing. The game transitions from a small-world network to something closer to a random graph — and the strategy changes completely.
For AI builders, the lesson is that the edit-distance graph is a useful proxy for evaluating how well a model understands lexical structure. A model that can play Wordit well — that can find the longest path through the four-letter word graph — is a model that has internalized something fundamental about English orthography. It is not a benchmark that anyone is running, but it should be.
The game that Ribeiro built in a day, while anxious about surgery, is a tiny window into the combinatorial heart of language. The models we build are doing the same thing, just with vectors instead of letters and probabilities instead of points. Wordit makes the structure visible. That is its real contribution.