The probe that caught gibberish: why we ran the name-maker instead of reading it
Our fox name-maker looked perfectly fine on the page. The word-list read pleasantly, and when we traced a few examples by hand — pick these sounds, stitch them together — the names came out warm and plausible. Then we did the one thing we hadn’t yet done: we ran the actual generator and printed what it really made. The optimistic reads fell apart in an instant.
This is a small story about a small piece of machinery, but the lesson under it is one of the load-bearing habits of the whole project. The feature itself — a generated given name and a family surname that descends down a line — is its own story, told from the player’s side. This post stays with the engineering, and specifically with the one moment that separates a tool you believe from a tool you’ve checked.
A name-maker, and a word-list held back on purpose
The naming machinery is deliberately simple: a name is stitched together sound by sound from an authored word-list, and a founder draws a single surname that the whole bloodline then carries unchanged. How it’s shaped and why it descends belong to the player-facing post; this one stays with the single decision that turned out to matter for the engineering.
When we wrote that machinery, we made one decision that turned out to matter more than any line of code: we shipped the assembler first against a deliberately fake word-list — obvious placeholder junk, clearly not final — and held the real fox vocabulary back as a separate pass to be done later, by ear. That separation was sound. Whether a name “sounds right rather than gibberish” is a feel decision, not a structural one. You can verify that the assembler picks three sounds per syllable and capitalises the first letter; you cannot verify, by reading code, that the result is a name a person would actually call across a meadow. That judgment lives in the ear, and we wanted to make it deliberately, with the real words in front of us, rather than smuggle it in while the plumbing was still wet.
The hand-read that lied
So the day came to author the real words. We wrote the fox vocabulary — soft opening consonants, plain vowels, gentle open endings, woodland-flavoured surnames — and we looked at the table. Reading it down the columns, it seemed obvious how the names would come out. You can see the pieces; you can imagine them snapping together; you trace a couple in your head and they’re lovely. The table read like it would produce exactly the warm register we were after.
It didn’t. The moment we ran the generator for real and printed a batch of what it actually made, the hand-traces were exposed as wishful. The first cut came out as gibberish — the very thing the whole word-list was supposed to prevent. Not because the assembler was broken; the assembler did precisely what it was told. The words were wrong in combination in ways that no amount of reading the list down the columns could surface, because the failure only exists in the product of the pieces, not in the pieces themselves.
A hand-traced example is a hope about what a generator will do. The generator’s real output is what it does. We had been grading the hope.
This is the trap, stated plainly: a generator is a multiplier, and you cannot eyeball the product of a multiplier by inspecting its factors. A word-list of fifty pleasant fragments can still combine into something that reads like a license plate. The structure can be flawless and the output still nonsense, and nothing you do by reading — not reviewing the list, not tracing examples, not being careful — will show you that. The only thing that shows you is the thing itself, run, with its true output on the screen in front of you.
The fix was to the practice, not the code
Here is the part worth keeping. The fix to this was not a change to the assembler. The assembler was fine the whole time. The fix was to how we work: stop trusting a hand-read of a generator, run it, read what it actually makes, and tune the vocabulary by ear against that real output — not against an imagined version of it.
So that’s what we did. With real names on the screen instead of in our heads, the tuning became honest. We could hear which fragments landed and which clattered, which endings opened softly and which snapped shut, and we refined the word-list over several passes until the generated names — the real ones, printed, not the traced ones — read like actual fox-folk. The probe was the discipline that caught it: not a cleverer review, not a sharper eye on the list, but the simple act of executing the thing and reading the truth.
The same machinery carries a smaller correctness check alongside the taste one, and we kept the two deliberately separate. One check asks a structural question — does a name come from the right word-list and have the right shape? The other asks a reproducibility question: does the same world and the same fox always yield the same name? Those are different axes, and conflating them is its own way to get fooled. A name can be perfectly reproducible and still be gibberish; a name can read beautifully and still re-roll differently on every load. We guard each on its own terms, and the “does it sound right” question is the one that lives outside both checks, in the ear, against real output.
Why we bother, for a handful of fox names
It would be fair to ask why this much care goes into something as small as a fox’s name. The answer is that the name is the first thing that turns an animal in the meadow into someone you tend, and a name that reads like a serial number breaks that the instant a player sees it. One unmistakably generated string undoes a great deal of quiet work. The cost of getting it wrong is paid by the player, in the worst possible currency — the spell breaking — and it’s paid silently, because nothing errors. The names just come out a little dead, and you don’t notice until you do.
This is the same instinct that runs through the rest of how we verify the game: that “no error” is not proof of being right, and that the most dangerous output is the one that looks fine while being wrong. A name-maker that runs cleanly and produces gibberish is exactly that failure in miniature — a green light over a broken thing. The probe is how you refuse to take the green light on faith.
After the tuning settled, we played a session to be sure the core of it held, and it did. The names that came out of the finished register read like fox-folk you could care about — Lella Marlowe, Maba Greenhollow, Bran Vesper, Lebron Honeywick — and because the word-list is just tunable content, not anything baked into a saved world, we can keep tuning the feel later without breaking anyone’s existing line. The machinery never changed. What changed was that we stopped believing it from the page and started believing it from the screen.
