The friction
Someone forgot the deck
Then someone keeps score on paper, and the rules get argued at every round.
Case · Consumer product · Party games
Atablo
Your phones are the controllers. Any screen is the table.
- Six card games, played together in the same room
- One device opens a room, the others join with a code
- Product, rules, design system and build run as one method
Tap a box: the table and the phone switch games.
The bet
Game night, without the box.
The insight
Everyone already holds a controller
A phone can show a private hand. A TV or a tablet can be the shared table.
The promise
Open a room, play in a minute
A four-letter code or a QR code. No account. The app deals, checks and counts.
The line-up
Six games, in a deliberate order.
Each game was picked for what it adds to the product, not just to the catalogue. Each one tests a new mechanic of the platform.
-
01
12 2 to 8 players
Flip, swap, aim for the lowest total. The first game set the contract every game now follows: a pure rules engine, hidden cards, rounds and scores.
-
02
7 2 to 18 players
Draw again or stop. Built in parallel with 12 to prove the contract holds for a second game. It brings the big tables.
-
03
6 2 to 10 players
Everyone plays at once. Cards are revealed in one go, then placed one by one, so the table can follow.
-
04
8 2 to 5 players
The classic 52-card deck arrives: suits, special cards, a direction of play that flips.
-
05
Président 4 to 7 players
Roles carry over from one round to the next: the winner and the loser trade cards before play starts.
-
06
4 2 to 4 players
The reflex game: anyone can play out of turn. The hardest real-time case, kept for last.
The method
A contract first, then the code.
Every change follows the same loop. Nothing reaches the main branch without its spec, its tests, and a decision on real screens.
- 1
Frame
A short proposal: why this change, what is out of scope.
- 2
Specify
Acceptance scenarios, one per behaviour. Open questions go to the decision maker, with a default.
- 3
Build
One change at a time, in an isolated copy of the code. Tests run after every file saved.
- 4
Challenge
An adversarial review reads the diff against the spec, scenario by scenario. It reports, never fixes.
- 5
Judge on screen
Captures at phone and desktop sizes, a floating list: OK or Not OK, with the reason.
- 6
Record
The spec is archived as the durable log of decisions. The next change starts from it.
Agents with roles
Plan, build, review: three separate contexts
One agent writes the plan and never touches the code. One builds. One reviews with read-only tools. The human decides between steps.
Mechanical locks
Rules written down, and enforced
Lint, types and the full test suite gate every change. A conformity suite checks that each new game respects the shared contract.
Fair play
No hidden card ever leaves the server
The server holds the deck. A player's screen only receives what that player may see, and tests check every message.
Iterations
Options side by side, then one decision.
No visual goes to code before a mock-up that convinces. Each question is shown as options on the same screen, and the call is written down with its reason.
Art direction
Three directions, one evening palette
Festive cartoon, boxes in volume, precious cards. Boxes in volume won, then the “Soirée” palette: night blue, milk-white cards, coral and mint buttons, a yellow halo for “your turn”. Built as the first skin of a system, so the next ones swap tokens, not code.
7 · A loaded hand
Twelve cards on a phone
In 7, a lucky player can hold twelve cards. Four layouts were mocked at full load. D looked smartest on paper. On a real phone, A read fastest: two rows, cards that shrink.
4 · Playing out of turn
Three taps was too slow
In 4, anyone can slap a matching card on the discard, even out of turn. Burning another player's card took three taps: too slow for a reflex game. Three gestures were mocked. The rule that came out: the first touch wins, and the game is capped at four players so every card stays in reach.
The mock-up loop
Judge on a picture, answer in one click.
Every open question becomes a page of mock-ups. Each option is drawn in a phone frame, in the theme's colours. A floating list sits in the corner, one line per question.
- 1
Options, with a recommendation
Each question shows its options side by side. One is marked “Recommended”, with the reason.
- 2
What is settled stays out of the way
Choices already validated and defaults applied sit in a box at the top. Nothing is judged twice.
- 3
Pick, OK or Not OK, comment
Tap the option's letter, or OK / Not OK. “Comment” opens a field only when there is something to say.
- 4
“Copy my feedback”
One button copies every answer and comment, ready to paste. The next version only shows what is still open.
v1first options, A to I→
v2card faces and back of 7 redone→
v3loaded hand of 7→
v4score pause of 4→
Full mock-up of 7every screen validated, then code
The room
Any device can be a player or the table.
- Table screen: the board, the scores, the QR code to join
- Player: your own hand and your actions
- Player + table: no big screen? Each phone also shows the others
The screens
One system, six personalities.
Same buttons, same halo, same rhythm. Each game keeps its own cards and its own moments.
Screens in French, the app's first language.
What comes next
From the browser to the stores.
- Now
On the web
Open a room from any browser, phone or TV.
- Next
iOS and Android apps
The same code wrapped as native apps, with real haptics on every phone.
- Then
Skins and a free tier
Soirée is the first skin. New skins as in-app purchases, ads in the free version, a purchase to remove them.
Quick facts
The details.
ReactTypeScriptViteWebSocket serverSeeded randomnessVitestOpenSpecClaude Code
Player counts from each game's definition and spec.
- 6card games, each with its own rules engine, tested on its own.
- 2 → 18players, from a duel of 12 to a full table of 7.
- 3roles per device: table screen, player, or both.
- 0hidden card sent to a player's screen.
- 1person: product, rules, design direction, agents, release.