Claude games — play what Claude can build

The classics Claude coded — and the hard part in each

The originals above are the showcase, but the bulk of the work is the arcade: the games everyone already knows, where there is nothing to invent and nowhere to hide a rules bug. Each of these is free, runs in the browser, and needs no account. Grouped by what Claude actually had to get right:

Puzzles where the generator has to prove the puzzle is fair

The hard part is not the board, it's guaranteeing every board it hands you can be finished — which means the generator has to solve its own output before it deals it:

• Sudoku — solvable without guessing, and the solution is provably unique.
• Minesweeper — no-guess boards; every board is proved solvable before you see it.
• Nonogram — picture logic puzzles with provably unique solutions.
• Klondike Solitaire — winnable-only deals, proved solvable before they are dealt.
• Mahjong Solitaire — every layout built to be finishable.

Card games where the rules engine is the product

These live or die on whether the engine can explain the rule at the moment it applies, rather than just enforce it:

• Bridge — a real auction, with every bid explained before you make it.
• Canasta — the board tells you whether you may take the pile, and why.
• Double Deck Pinochle — the meld cheat sheet, live, against your own twenty cards.
• Pinochle (two-handed) — the board states the rule in force and counts the other hand.
• FreeCell — Microsoft deal numbers, and it tells you when a deal is dead.
• Spades (bags, nil and blind nil), Hearts, Euchre, Gin Rummy, Rummy, Cribbage and Crazy Eights — full scoring, provably fair deals, no coins.

Board classics that need a real engine, not a lookup table

• Chess with a free review engine, and Chess960 across all 960 starting positions — castling shown before you play it.
• Chinese Chess (Xiangqi) — river and palace done properly — and Shogi, drops included.
• Go (9×9) — scoring that can't be argued with — and Connect 4 on a solved engine.
• Backgammon and Liar's Dice — provably fair dice; Liar's Dice prices every legal bid from your own cup.
• Gomoku (the overline rule done right), Nine Men's Morris, Checkers, Reversi, Chinese Checkers and Mancala — every difficulty level free.
• Carrom — multiplayer rooms, joined with a four-letter code — plus Dominoes on a verifiable shuffle, Bingo that names the balls that would win, and Hangman whose word is hashed before you guess.

Same rule as the originals: where a claim can be checked, the game ships the check. The dice and deals that say "provably fair" can be recomputed from the published seed in the verifier.

What Claude actually had to get right

"Made with AI" usually means a toy. The useful question is what the code has to do and whether anybody checked it, so each of these games ships a verifier or a measurement — the only way to tell a working engine from one that merely runs:

• MOGUL decides whether to buy a property with a small neural value net instead of a rule of thumb: 464 sparse binary features into an accumulator, then 256×32 and 32×1 layers, read as a win probability. It beat the hand-written heuristic it replaced 0.483 to 0.240 over 800 four-player games. The weights are int16-quantised at scale 1024, which costs at most 0.021 logits against the float net. The decision itself is one ply deep — evaluate the position with the property and without it, take the better number.
• OVERRUN resolves attacks from exact odds rather than a fudge factor: all 6⁵ = 7,776 dice outcomes are enumerated, and the resulting table is asserted against the published figures every time the engine loads. On its top difficulty it declines any attack below a 44% win chance. Measured over seventy games per pairing, Marshal beats Captain 66%, Captain beats Recruit 80%, and Marshal beats Recruit 93%.
• CLASP searches with alpha-beta, iterative deepening and a node budget. Its move generator is verified by perft against Mzinga, the reference engine for this family of games — agreeing on 12,219,480 positions at depth six, and stopping there because the two best-known implementations disagree beyond it.
• LEXEME plays on a 13×13 board from a 96-tile bag against the 172,820-word public-domain ENABLE list. Its move generator follows the standard published algorithm and is cross-checked against a deliberately slow second generator, so a fast bug has nowhere to hide.
• ANTE is a solitaire run of eight antes, three blinds each. Its hand scorer was cross-verified against an independent Python implementation on 4,000 random hands — agreeing on the classification, on which cards score, and on the final number.
• HOLESHOT integrates a longitudinal physics model in 1 ms steps and checks itself against the standard drag-racing estimators for elapsed time and trap speed, agreeing to about 2.5% on average across thirty weight-and-power combinations. Difficulty changes the bot's reaction window and its shifting, never its car.

The limits are published on the game pages too, because they matter more than the wins: LEXEME does no lookahead and no rack-leave evaluation at any level, OVERRUN never searches past the current turn, and MOGUL's net is consulted one move at a time. Claude wrote all of it; a human decided what had to be proven before it shipped.

Make your own Claude game in one sitting

Claude builds games as artifacts — self-contained HTML files that run right in the chat. The short version:

1. Ask for the game as "a single self-contained HTML file, all CSS and JS inline, no external requests." That one phrase is the difference between a shareable file and a pile of fragments.
2. Play it in the artifact preview. Tell Claude what feels wrong in plain words — "the jump floats too long", "I can't tell whose turn it is." Iterate three or four times; the first version is never the good one.
3. Download the artifact as an .html file (or copy the code into mygame.html).
4. Upload it here. Artifact share links require signing in and can't be indexed — a hosted page is how strangers actually find and play your game.

Full prompt templates and pitfalls: How to make a game with AI.

What Claude is strongest at

From building every game on this site: Claude shines at game logic and opponents — legal-move generation, AI players that put up a fight, turn structure that doesn't break under weird inputs. It's also strong at keeping a whole game coherent in one file as it grows past a thousand lines. Like every model, it needs playtesting feedback from you: it can't feel that the difficulty curve is off until you tell it.

FAQ

Are these games actually built with Claude, or just designed with it?

Built with it. For every original above, Claude wrote the game loop, the rules engine and — in the games that have an opponent — the bot's decision-making; a human playtested each one and sent it back until it held up. The classics in the free arcade — chess, go, backgammon, hearts and the rest — were coded the same way.

Do I need a Claude account to play them?

No. Nothing here needs an account, an email or an install, and you don't need a subscription to any AI model — the games are ordinary web pages that run in your browser. There are no ads, no coins and no energy timers, and every difficulty level and analysis tool is free. Multiplayer games are joined by sharing a four-letter room code.

How do I know the dice aren't rigged?

You can check them yourself. In the originals that roll dice — MOGUL, OVERRUN and HOLESHOT — the game publishes a SHA-256 hash of its server seed before the first move and reveals the seed when the game ends, so every roll can be recomputed afterwards. Roll i is derived from SHA-256(server : client : i : counter), and each byte becomes a die with (byte mod 6) + 1 — bytes 252 to 255 are discarded, because 256 is not divisible by 6 and keeping them would make low faces slightly more likely. Because the seed is committed before you play, the dice can't depend on how well you're doing. Paste a finished game's receipt into the dice verifier and it recomputes the sequence from scratch; if one die had been changed, the check fails. The SHA-256 is plain readable JavaScript, checked against the vectors published in NIST's FIPS 180-4.

How do I turn a Claude artifact into a game I can actually share?

Artifacts are Claude's side panel for self-contained code, and a game built as one runs right there in the chat — see Anthropic's guide to artifacts. Ask for the game as a single self-contained HTML file, iterate in the preview, then download it. That file is yours to host anywhere; upload it here and it gets a permanent, linkable page instead of living behind a share link that needs a sign-in.

Is hosting my game here free?

Yes — free to submit, free to host, free to play, and you keep every right to your game. A human reviews each submission before it goes live, and community games run in a sandboxed frame. Ask us to take yours down at any time and we will.