Zombicide Companion A companion app that steps aside for the game.

Context

Zombicide is a cooperative board game: players join forces to survive waves of zombies.

One evening, at a get-together at a friend's place, he introduced me to the game. He had noticed my interest in the box, and ended up offering me a game to try. I was hooked right away.

Seeing the growing interest in AI in the Product Designer job, and not wanting to be left behind, I decided it was time to learn Claude Code. What better way to learn than a real project: a companion app for the game. The idea quickly grew: it now handles the 2nd edition and Invader, and can welcome other versions.

Problem

V1 worked, but it played too much in the players' place. A single attack took eight interactions: pick the survivor, their weapon, the targets, the rerolls, friendly fire… where the physical sheet needed none. The other features had the same heaviness.

I tested this version over two games, with three players at the table each time. The feedback was blunt: the app took over the game. Those verbatims, far more than my own instincts, shaped what came next.

Goals

• Don't weigh down the game: the app assists the game without taking its place.
• Make a game playable from start to finish, on one or several devices.
• Keep a single app for several versions of Zombicide.

Approach and lessons

Frame before coding: the rules and edge cases are set out upfront. A single principle guides every choice: only add what's missing. Each feature is first tested on a playable demo before being kept.

Solution

Rather than fixing V1 piece by piece, I decided to start from scratch. I kept the stack, but not the code: every rule, every edge case and the architecture were laid out before writing a single line. The rules engine stays pure, independent of the interface and the network, which later makes it reusable on the multi-device side.

The starting principle fits in one sentence: you only add a feature if it is truly missing at the table.

Principes de conception

The app follows the game, but the players decide. It never makes a choice in their place.

An action is only spent at the moment it is confirmed, and every mistake can be undone. + and − buttons are everywhere, to correct quickly without digging through menus.

Values like experience or damage are computed from the game: you never enter them twice.

Fonctionnalités clés

The rules: the round loop

1. The survivors play. Each one takes their turn, then confirms “End of turn”.
2. The Xenos go hunting. The app shows the phase, and players enter the damage taken.
3. A new round begins. The game resumes, with the round counter updated.

The rules: oxygen

1. The tank isn't drawn at random: it is found in the oxygen room, and it's reusable. It never goes to the discard pile.
2. The app keeps its own stock of tanks, separate from the search deck. Declining a card, or discarding it later, puts it back where it belongs.
3. The “Oxygen” action costs one action, with no limit per turn, as the rulebook states.
4. The app doesn't check that the survivor is actually in the right room. It's up to the player to be honest: the app applies the rule, it doesn't police the table.

The rules: the Mold Spawn

1. The Mold Spawn isn't a loot card, it's an event. You place the miniatures, and the card goes to the discard pile.
2. The survivor still draws their card: the app draws again behind it, as many times as needed.
3. The banner doesn't number the Mold Spawn, so it doesn't suggest you draw two cards, and it shows that a new card follows.
4. A first version had lost this loop: landing on a Mold Spawn cost an action for nothing. Fixed after feedback during a test game.

The tech: a game that works offline, and over the network when you want it

An installable app. It installs like an application on a phone or tablet, and works without a connection in single-device mode.

Several devices, one game. A server (a Cloudflare Worker) connects the devices in a shared room, joined with a code. It is the source of truth: if a player's connection drops, they return to the game exactly where they were.

The same rules everywhere. The rules engine is the same on the device and on the server. A confirmed action is the same on both sides.

A spectator screen. A screen on the table, or on another device, shows the game live. It keeps only the information useful to everyone: the round, the threat, the survivors and their key actions. It also supports immersion, with the phase screens and the survivor deployment screens.

Immersion: each game has its own staging

The dice. In the 2nd edition, the dice bounce on the asphalt. In Invader, they materialize as phosphor wireframes. The result is drawn before the animation: it decides nothing, and a tap ends it.

The turn announcements. Every announcement has its own screen. In the 2nd edition, it's an ID photo that gets stamped. In Invader, it's an agent file, then an end-of-turn report.

The character creation flow. In Invader, the home screen powers down, the flow powers back up, and the steps light up one by one.

The mission briefing. It opens in a system-style window, and the plan unfolds in a second window on top.

Everything switches off automatically if the system asks to reduce motion (an accessibility setting).

The diceTurn announcementsThe character creation flowThe briefing

In the 2nd edition, the dice bounce on the asphalt. In Invader, they materialize as phosphor wireframes.

Deux versions du jeu

Zombicide exists in several editions, and each has its own rules. The 2nd edition and Invader share the same rules engine, but each version has its own reference set: its cards, its machines, its missions.

You choose from the home screen. The app then adapts the survivor sheet, the creation flow and the staging.

Two versions, one engine

Choosing a version2nd editionInvader

On the home screen, you choose between the 2nd edition and Invader.

Results

An attack goes from 8 interactions to 2. The app handles two versions of the game, installs on a phone or tablet, and works without a network in single-device mode.

It was validated over about ten real games. Every game surfaced bugs and feedback, fixed before the final version.

The first load of a game version takes under 5 seconds, measured in real conditions on a device that had never used the app.

Reflections

• Real tests are worth more than mockups. Two games with three players were enough to overturn the design of V1.
• Lock the rules before coding. The reference rule is a verified summary, and the rules engine is pure: it can also run on the multi-device side.
• Claude is powerful with a framework. A handover document, kept up to date, made it possible to restart a session per workstream without losing consistency or burning tokens.

What's next

A native version if demand justifies it. In time, the app would include every version and expansion of Zombicide.