Most input validation is invisible. You type something wrong, you get an error, you move on. Nobody designs a game around it.
But there's a small browser horror game called Suzy Says that does exactly that — it takes the most boring concept in software (checking whether a command is valid) and turns it into the entire source of tension. Playing it made me rethink how I structure validation in my own projects, and I think the pattern is worth stealing.
The mechanic
A TV host gives you instructions. Some are valid, some are traps. The rule is the classic children's game:
- "Suzy says: jump" → execute
- "jump" → ignore That's it. No combat system, no inventory, no physics engine doing the heavy lifting. The whole game is a string prefix check.
And yet it works, because the difficulty isn't in understanding the rule — it's in applying it under pressure. The commands speed up. The wording gets slightly less obvious. You start responding to intent rather than to text, which is precisely the mistake the game is waiting for.
Why this is a good design
From a systems perspective, the game has almost no state. It needs:
function isValidCommand(input) {
return input.trim().toLowerCase().startsWith('suzy says');
}
function handleCommand(input) {
if (!isValidCommand(input)) {
// ignoring is the *correct* action — not an error
return;
}
execute(input);
}
Two functions. That's the core loop.
The interesting part is what it does with the failure case. In normal software, an invalid input is a no-op. Here, ignoring a valid command and following an invalid one are both punished, but differently — and the player has to track which failure they made. That's a much richer state model than a boolean.
It also means the game can be built with almost no content. Change the command list, the timing, and the penalty, and you have a new difficulty tier without touching the architecture. For a solo dev, that's a very cheap way to get a lot of playtime out of a small codebase.
The transferable lesson
I've been building forms and APIs for years, and this game made me notice something I'd been doing badly: I treat validation as a gate, not as a mechanic.
A gate says yes or no and moves on. A mechanic gives the user feedback about how they got it wrong, and makes the difference legible. The game works because you can feel the difference between "I obeyed a fake command" and "I ignored a real one" — they produce different deaths.
In a form, that maps to distinguishing "this field is empty" from "this field is formatted wrong but probably recoverable." In an API, it maps to returning why a request was rejected rather than a flat 400. Neither is hard, but both require thinking of validation as part of the experience rather than a checkbox.
One caveat
The pattern only holds if the rule is unambiguous and the player can learn it in seconds. Suzy Says gets away with it because the rule is one sentence long and culturally familiar. Apply the same idea to a rule that needs a tutorial, and the tension collapses into confusion.
Simple rule, strict enforcement, visible consequences. That combination is doing all the work — and it generalises well beyond horror games.
If you want to see how the mechanic actually plays, the write-up and browser version are at Suzy Says — it takes about ten minutes to finish, which is roughly the length of a coffee break.
Top comments (0)