Josh Rutz · How Zipix ships games
Idea to game.
One designer. One pipeline. 25 live micro-games.
The system that turns a one-line idea into a playable build on the dev feed, built one lesson at a time.
Scroll
The frame

A studio is a process, not a headcount.

Zipix runs on one designer and a pipeline of AI specialists. Every discipline a studio would hire for exists as written process: design, balance, engineering, QA, release. An agent runs the process, a human audits the output, and each new game starts with everything the last one learned.

Where it started

The first games were built the old way.

Spring 2026. Hand-ported Phaser scenes, no design docs, no pipeline. Every game re-learned the platform from scratch, and re-hit its traps.

0
Commits of trial and error to ship the first game
0
Design docs among the first eight games. Code first, questions later
0
Days between games on a good stretch
Every new game paid the full cost of the last one.
The lessons

Every bug we hit once became a rule no game can break twice.

Fuzzy canvas
Retina rendering was blurry in every game. Now the platform owns canvas scaling; games never touch it.
Ghost replays
Phaser reuses scenes, so replays inherited stale state and instant wins. The engine now snapshots every game's clean state and restores it each round.
Dropped taps
Phaser tracks one finger by default; fast alternating taps silently vanished. Multitouch is now on for every game at the factory level.
Stale releases
The CDN caches each version forever, so a republish served old code. Every change ships with a version bump in the same commit, and a gate checks.
The turn

Stop re-teaching the machine. Write the studio down.

Every lesson moved out of memory and into four skills: how to design a game, how to price its difficulty, how to build it, how to ship it. They load on demand, and a new game starts from all of them.

Designing a game
272 lines
Pricing its difficulty
416 lines
Building it
440 lines
Shipping it
63 lines
The cost curve

Commits to ship each game, in order.

Every bar is one game, from the first to the newest. The two dashed lines are the days the skills landed.

43
32
35
37
39
37
42
36
31
Build skill lands
21
21
13
26
Design + difficulty skills
16
11
16
16
28
7
9
3
6
7
6
17
tap_target · March 2026globe_tap · June 2026

Total commits touching each game, in the order they entered the repo. The late bump is globe_tap, a spinning-globe geography experiment that earned its extra commits.

The pipeline

Five stages between a sentence and a live build.

Idea Design Difficulty Build Verify Publish Live on dev
01Design
A nine-section questionnaire turns the idea into a design doc, plus an interactive mockup you can play before any code exists.
02Difficulty
Independent levers, stepped on skill-tier boundaries, sanity-checked with headroom math.
03Build
A thirteen-step scaffold with test-driven development on everything that computes.
04Verify
Unit tests, a local prepublish that mirrors CI, patch notes, and a human playtest at three skill levels.
05Publish
Version-bumped, published to an immutable CDN, live on the dev feed the same day.
The toolbelt

Every skill in the chain, in the order it runs.

Each one is a written playbook the agent loads at that moment. Names are the real file names in the repo.

Design
designing-a-zipix-gameThe nine-section questionnaire that turns the idea into a design doc and playable mockup.
designing-game-difficultyPrices every lever in human seconds and steps it on tier boundaries.
Build
creating-a-zipix-microgameThe thirteen-step scaffold: scene, config, tests, the traps already solved.
test-driven-developmentRed, green, refactor on every generator and solver.
aesthetic-systemColors and fonts come from semantic tokens, never hex codes.
Polish
zipix-art-directorThumbnails and in-game art, held to one house style.
antislopEvery word a player reads gets scanned for AI tells before it ships.
Ship
requesting-code-reviewAn independent review pass before anything is allowed out.
publish-gameVersion bump, prepublish gates, immutable CDN, live on the dev feed.
Design

The design doc is something you play.

Every game design ships with an interactive mockup: the real difficulty formulas behind a slider, the actual screen anatomy, the mechanic live on a canvas. Timing and feel are not reviewable in prose, so the review is a play session. Approval means it was already fun on a fake canvas.

shape_count · mockup
0:14
skill 0.60 · Gold tier
Play round
The rails

Eight rules no game gets to reinvent.

One puzzle per game
Binary win or loss
Difficulty served, not chosen
An absolute timer
Six skill tiers
Portrait, thumb-first
Tokens, never hex codes
No pay-to-win

The questionnaire designs inside these walls. When a concept collides with one, the process reframes it to keep the intent, or rejects it, and says so out loud. Constraints are what make 25 games feel like one product.

Balance

Difficulty is arithmetic before it is playtesting.

Every lever gets a cost in human seconds, and every lever steps on a tier boundary. The math gets you close; a human calibration loop lands it. Shape Count took four rounds.

round timer ÷ units × seconds per unit × rework = headroom
Bronze
Silver
Gold
Platinum
Diamond
Legend
Win-rate targets
A tier below your skill: near-certain
At your ceiling: about 50%
A tier above: brutal
The gates

The AI writes the code. The gates decide if it ships.

Code out of the build skill
Unit tests
Generators and solvers are written test-first. The difficulty curve itself is asserted.
Prepublish
Every CI check runs locally in seconds, so nothing iterates against a red build.
Patch notes
No version ships without human-readable notes, enforced by the same gates.
Human playtest
Three runs, at beginner, median, and ceiling skill, before anything goes live.
Live on the dev feed
What it changed

Design moved ahead of code.

Approved designs now queue up waiting to be built, and building one is the cheap part. The record so far: three games shipped in a single day.

0
Live games on one shared engine contract
0
Commits to ship a game at the current best, down from 43
0
Games in one day, each from its own queued design doc
3
Mar
4
Apr
12
May
7
Jun
New games per month. The skills landed in May.
A platform fix now lands on every game in one pass. Under the old model, that was 24 hand-edits, each one a chance to miss a game.
What it adds up to

Build the studio once. Every game inherits it.

The games are small on purpose. The pipeline is the real product: every lesson kept, every gate written down, and a human deciding what ships.

Josh Rutz joshrutz.com playzipix.app [email protected]