Every card game in my hub is a game of play. You hold cards, you put cards down, the cards decide. I wanted one where the cards barely matter and the person across the table does.
The Problem
Bluffing games are the best kind of card game and the hardest to play alone. The good ones need a table of people who know each other well enough to read. Play them against a computer and you usually get one of two failures: an opponent that cheats by looking at your hand, or an opponent so simple that its bluffs are obvious after twenty minutes.
What It Is
Everyone holds cards nobody else can see. You make claims about every card on the table at once, not just your own, and each claim has to beat the one before it. Pair of nines. Two pair. A straight. A full house. Instead of climbing higher you can call, and then every hand turns face up. If the claim was really there, the caller takes a card. If it was a fib, the fibber does.
You start with one card and take another every time you lose. At seven you are out. Last player standing wins.
The clever part is that the table gets more crowded every round, so high claims get safer and calling gets riskier. The game turns from a bluffing contest into a nerve contest without changing a single rule.
The Ladder
There are 340 possible claims, held in one fixed order so that beating the previous claim is a single number comparison. High card, pair, two pair, three of a kind, straight, flush, full house, four of a kind, straight flush. No kickers, because kickers multiply the possibilities enormously and give a liar nothing extra to work with.
One rule surprises everyone who plays it: a claim is a floor, not a description. Say “a pair of nines” and four nines on the table satisfies it. The question is only ever whether those cards are present, never whether they are the best hand out there.
The Opponents
Three of them, and none can see your cards. That is a property of how the code is written rather than a promise: the function that decides a bot’s move takes the public state and that bot’s own hand, and there is no parameter through which anyone else’s cards could arrive.
Each one works out the actual probability that a claim is true, given its own hand and the cards it cannot see. That maths is exact rather than estimated. Every kind of claim turns out to have a closed form, so there is no simulation and no randomness in the reasoning at all.
All three difficulty levels share that same calculation. What separates them is nerve, not intelligence: when they call, how much they need to believe a claim before making it, and how hard they push the ladder. That was a deliberate choice. If the levels differed in how well they calculated, one could accidentally become strong because of an arithmetic mistake, and nobody would be able to tell the difference.
Getting that ordering right took actually playing them. An early version had the hardest opponent quietly losing to the medium one, and no amount of reading the code showed it. Twelve hundred simulated matches did.
What I Learned
Every real bug in this build was found by running something, never by reading it. The difficulty ordering came out of playing a thousand matches. A miscounted card and an empty control panel both came out of looking at a screenshot. An entire untested code path came out of opening the game in a browser for the first time.
The most useful test I wrote does not check that the code works. It checks that the tests can fail. I deliberately broke the probability maths in the most plausible wrong way, and every single test still passed. Fixing that gap mattered more than anything the passing tests had told me.
Not Included
No accounts, no backend, no ads, no tracking, no network of any kind. Nothing leaves your device.
No chips, no pot, no wagering, and no money language anywhere. The loser of a round gains a card, and that is the whole economy. There is a test that reads the actual words on screen and fails if any betting vocabulary creeps in.