NOTES.

Field notes from a one-person shop. Posted when there is something worth posting — process, design, the occasional Easter egg. Receipts at the bottom of every page.

ARCHIVE40 ENTRIES

01
The heartbeat
My merge gate went 52 minutes without merging anything, and nothing said so. By morning the heartbeat my agents built to catch stalls like that had fooled itself twice with one git check, on branches that had no work on them yet.
TL;DR
- One night in October, the script that merges my game's code changes merged nothing for 52 minutes after the disk filled up halfway through a merge, and nothing reported it. The watcher on that script looked for particular words in its log, and the failure used a word it was not looking for.
- The fix became a heartbeat. Every five minutes, plain rules check that each part of the pipeline is still moving. A small local AI model only suggests causes for new problems, and the heartbeat was allowed exactly one action of its own: handing the next queued task to an idle worker.
- By morning it was taking two more actions, added overnight after I told the agent running the pipeline to stop waiting for my call, and both went wrong the same way. It asked git whether a branch was already part of the main code, and a branch created moments earlier, with nothing on it yet, passes that test. So it released a task too early and struck known failures off the list of failures the merge script may ignore. It now trusts only branch versions the merge script has actually tested.
- Two other stalls that night became new rules by morning: a stray script that never quit and held up the tests that need the whole machine for close to half an hour, and a health check that mistook a worker waiting in line for a stuck one.
gamesai-agentsverificationprocess
DATE2026-10-05READ7 MINSLUG/the-heartbeat
02
When the test is the bug
Over one weekend, the failures my game's merge gate reported kept turning out to be the tests or the test machine rather than the code. The work became telling the two apart without learning to ignore red.
TL;DR
- AI agents write most of the changes to my game, and an automated gate re-runs each change's tests before letting it merge. In one overnight stretch of a busy weekend, 18 of the 23 new failing results it reported, retries included, came from the tests or the test machine rather than the game's code. Claude, the coordinating agent, did that sorting from the gate's logs and the commits that followed; the machine-starved part is inferred from each run's own physics rate, not re-measured on a quiet machine.
- The single biggest cause was a crowded machine: with up to eight agents' tests running at once, the game's physics ran at roughly a third of its normal rate, and the tests that time loading kept failing. Those results are now recorded but not allowed to block a merge when the run's own physics was starved. That rule has a blind spot, and a daily test on a quiet machine is meant to cover it.
- Ten more came from tests left stale by deliberate changes, such as rain that now leans with the wind, or from tests with bugs of their own. Outside that count, the morning added one more: the test script cut off the import of new 3D models after two minutes, so some of about fifty new models measured zero in size.
- The tests also caught real bugs, including a worker stuck forever at the village wall, which starved the village of wood. Two proposed speedups to the test pipeline were measured, came in small and were shelved; two plain changes shipped instead.
gamesgodotai-agentsverification
DATE2026-10-05READ7 MINSLUG/when-the-test-is-the-bug
03
Fifty-six models faced backwards
Most of the AI-generated 3D models my pipeline had stalled on were built exactly as asked. A rotation setting Blender silently ignored had left them facing the wrong way, a review script that found the word 'boar' inside 'keyboard' misjudged what some of them were, and nobody had looked at the rest again.
TL;DR
- Over one weekend, AI agents made 3D models for my game with Tripo, a text-to-3D tool, checked them, cleaned them up in Blender and put them in the game. A one-line bug in the cleanup step meant its turn-the-model-around setting did nothing, and nobody checked: 56 of 126 models ended up facing backwards or sideways, including 20 of the 21 human characters.
- The checking step had a bug of its own. It guessed what kind of object each model was from words in its description, so two backpacks were judged as people and a computer terminal as a four-legged animal, because the word keyboard contains the word boar.
- 47 models had been marked failed or were still waiting for a second look. 42 of them passed without generating anything again: turned the right way round, re-checked as the right kind of object, or simply looked at. The only new money spent on the 47 was 45 credits, Tripo's unit of usage, for a deliberate rewrite that gave a machine gun its ammunition belt.
- Tripo did get a few things wrong, such as bushes that came out as small trees. Most of the failures were ours, and the cheapest test, re-checking a file already downloaded, should come before paying to generate a model again.
gamesgodotai-agentsverification
DATE2026-10-05READ8 MINSLUG/fifty-six-models-faced-backwards
04
The harness was the slow part
A local model looked too slow and too lost to work on its own, so I measured what it was being fed. On every turn it read about 30,000 tokens of instructions written for a different model, and every task started in the wrong folder.
TL;DR
- I asked a free local model, Qwen 3.8 running on two ordinary 16 GB graphics cards, to do most of the coding on my game while Claude reviewed its work. Asked to hunt for bugs across the whole codebase, it was mostly wrong: of 137 findings it rated most serious, Claude confirmed 4. That covers open-ended review only.
- Given small, exact jobs, it did well. It rewrote the game's crops as real plants and fixed the puddles in a few short rounds; Claude corrected its slips and checked every result.
- Working on its own, it looked hopeless: four of its first six tasks ran over an hour without changing a file. Neither cause was the model. Every step it took re-read about 30,000 tokens of rules written for Claude, and every task started in my home folder instead of the game's.
- With both fixed, it solved a test task correctly in under 14 minutes and started shipping real changes on its own. Each mistake it makes now becomes a written rule it reads before its next task.
aiprocessverificationgames
DATE2026-09-29READ5 MINSLUG/the-harness-was-the-slow-part
05
The contract came first
My game's clouds went from painted puffs to a volume you can fly through in one evening. The part worth writing about is what happened first: after three weeks of water detail that vanished while every test passed, the rules for what the clouds must show were committed before a single pixel changed, and the first build failed them on four counts.
TL;DR
- My game's clouds used to be soft puffs drawn at a fixed height above the player's eyes, so no one could ever reach one. The first version of real, three-dimensional clouds now wraps the planet 1.2 to 4 km up, and you can fly up through them.
- Making the water look real took three weeks, and most of the detail lost along the way never reached the screen while every test passed. So before any cloud was drawn, each cloud effect got a test that renders the same frame with the effect on and off and fails if the difference is under a threshold written down in advance, and nothing that changes the look merges until I approve it.
- It caught real problems in the first build. The effect that frays cloud edges measured just under its threshold, 1.13 against 1.15, and the threshold stayed where it was. A later run read it above the threshold, and whether that is a real change or noise in a single measurement is still open. Flying fast smeared the clouds at five times the allowed amount until a fix brought it inside the limit.
- It is not finished and not merged. Sunsets are oversaturated, the inside of a cloud is a flat grey, and my own first reaction was that the clouds seem really far away. Lighting and real-world cloud types come next.
gamesgodotverificationtesting
DATE2026-09-24READ9 MINSLUG/the-contract-came-first
06
Where the ripples went
Three weeks of making the water in my game look real were mostly a search for detail the math already had and the screen never showed. Twice the culprit was the same one-line mistake, and once the fix was to draw less.
TL;DR
- Making the water in my game look real took three weeks, and most of them went into finding detail that the math had and the screen never showed. Twice the cause was the same mistake: a direction lying flat along the planet's surface multiplied against a position, which on a sphere always comes out close to zero.
- The first time, the whole ocean rose and fell in one piece with no waves across it, for eight days. The second time, every small ripple collapsed into one flat tilt; fixing it nearly tripled the fine detail near the camera.
- The foam got better by covering less. The old shoreline foam was a white sheet over about 31% of the water; the new lace covers about 3%, and I overruled the test that called that too little.
- The game's anti-aliasing then erased about 61% of the new detail. A sharpening pass that touches only the water pixels won most of it back, doubling the near detail, without adding flicker.
gamesgodotverificationtesting
DATE2026-09-23READ8 MINSLUG/where-the-ripples-went
07
Nothing merges on its own word
I let my coding agent run up to sixteen other coding agents at once against one game for a day and a half, and told it nothing merges without a rerun of its own tests, before and after. Three separate times, something passed every test it had and simply was not on screen when anyone looked.
TL;DR
- My coding agent spent a day and a half coordinating up to sixteen other coding agents working in separate copies of the same game, and it does not take any of their word for it: every finished piece of work gets its own tests run again, by the coordinating agent itself, before it goes into the shared copy and again right after.
- The account's own usage limit shut down every one of those agents twice in one evening, the second time five minutes after the first recovery. Nothing was lost, because the work was already saved to the project's history and every test's result lived in a file, not in a conversation.
- A new ocean effect vanished from the screen three separate times for three different reasons — twice with a clean checklist and no error anywhere, and a third time caught by a test within seconds, because the first two vanishings had taught the suite what to watch for.
- One test written the same day for a brand-new networking feature caught a bug in that feature's own code before a player ever saw it: one duplicate message code had been silently deleting every edit a player made to the world.
gamesgodotai-agentsverification
DATE2026-09-21READ7 MINSLUG/nothing-merges-on-its-own-word
08
The probe that refuses to run
A game built with an agent stays honest because 260 probes and 30 capture rigs judge it, and because the runner they go through knows when it is not allowed to run.
TL;DR
- A probe is a scene that boots the game's planet, asserts one thing, prints its verdict and exits. There are 260 of them, plus 30 capture rigs that shoot frames for the thresholds to judge, and the runner that launches them is the only way to launch one.
- The runner refuses to run while a game is open on the machine, refuses while another probe is mid-run, mutes the audio, backs up my saves and puts them back. The two refusals each come from a specific bad night.
- A probe cannot judge how a frame looks. It can judge that a frame was drawn, that the water is teal and not grey, that the foam along a shore breaks instead of running as one solid white line, and that a red desert measures red. Whether it looks good is mine to judge, playing it.
- The last full run of the suite took 41 minutes. 171 probes printed a verdict and 168 were green; the runner counted eleven red, three that said so and eight that timed out or threw before they could.
gamestestingprocessai
DATE2026-09-14READ6 MINSLUG/the-probe-that-refuses-to-run
09
The crash was in the quit
One probe in my game's test suite passed and then died on the way out, almost every time, and I had taught the runner to forgive it. The bug was a third-party queue that runs its leftovers inside a destructor, after the physics world they need is already gone.
TL;DR
- My game's test runner had a rule that counted a crash on exit as a pass, because the crash came after the test had already printed its own pass line. The rule was wrong: the player's exit is the window's X, and the X went through the same crash.
- The cause was in the voxel terrain add-on the game uses, read at the exact version it ships: deleting a terrain chunk is deferred to a queue whose cleanup code runs whatever is left in it, and the game engine, Godot, destroys that queue after the physics world those deletions need is gone. The add-on's author filed this bug in 2022, and it is still open.
- The fix is a short function in the game, not the add-on: read the add-on's own count of what is still in that queue, keep rendering frames until it reads zero, then quit. Six crashes of six became zero of six the same afternoon.
- Ten of the suite's test scenes were made to quit over and over; one crashed and nine never did, and that was the clue. The one that crashed never lets the terrain finish loading and unloading before it quits, so the shared queue is at its deepest when it does.
gamesgodotdebugverification
DATE2026-09-14READ5 MINSLUG/the-crash-was-in-the-quit
10
No river runs uphill
The planet under my survival game is one JSON entry. Everything wet on it — rivers, lakes, the coast, the mill — falls out of a single rule: water goes downhill, and only downhill.
TL;DR
- One rule makes every river: water at any of 90,000 points on the planet's surface moves to a lower neighbor, or stops where it can go no lower, which is where a lake forms or the sea already is. Nothing flows uphill, so a river you follow always ends in one of those two places.
- The worst water bug was a missing fact, not a wrong formula. The code that routes water downhill had never been told an ocean existed, so 2,083 river points and 107 lakes sat underwater. Once sea level was fed to it, none did.
- Each planet is one entry in a JSON file: 25 settings, with a check that every setting is spelled right and actually read by something.
- The same 25 settings produced the same heights and the same river network, byte for byte, in two separate runs on one machine. A co-op game could then send each player the settings instead of megabytes of terrain. So far that is proven for the heights and the rivers, not for the meshed ground. The next step is a random-seed setting: one number that rolls a different planet.
gamesgodotalgorithmverification
DATE2026-09-14READ8 MINSLUG/no-river-runs-uphill
11
The loop is the product
I built the v0 loop in a day — live preview, forked versions, design tokens, export into real repos — then swapped three different engines into it. The loop barely noticed.
TL;DR
- One day of agent-driven building produced a personal v0: describe a UI, watch it render live, refine it by chat, and export the file into a real repo — 3,089 lines, 79 unit tests, 10 browser tests, public on GitHub.
- The same tool ran on three engines — a small local model, the Anthropic API, and Claude Code itself running headless — and switching engines is one environment variable.
- Asked for the same small change, the local model rewrote 132 lines; Claude changed 2. The loop worked on both; the difference was knowing what not to touch.
- A subscription login token is not an API key, no matter how much it looks like one. The legitimate way to spend a Claude subscription inside your own tool is through the Claude Code CLI.
ownershipaiprocess
DATE2026-08-22READ5 MINSLUG/the-loop-is-the-product
12
The second voice
I asked my coding agent why I was hearing it twice. It traced its own process tree, discovered it had no terminal window, and found the second voice was itself.
TL;DR
- A session picker, a 167-line local bridge, and one browser page turn any Claude Code session into a spoken conversation — 934 lines across four files, counting the installer.
- The AI half was nearly free; the agent already knew how to resume a session and answer a single prompt. Almost all the real work was audio: echo, interruptions, and choosing the right microphone.
- The strangest bug was hearing two voices answer at once. The agent traced its own processes to find the culprit and discovered the second voice was itself, speaking through a channel nobody had closed.
- The payoff is speed: two or three spoken sentences instead of paragraphs to read, and a conversation you can have from across the room.
aiinfrastructureprocess
DATE2026-08-20READ4 MINSLUG/the-second-voice
13
Half a step early
Every timestamp my video QA tool reported was off by the same half-interval, and the test I wrote to protect the contract was protecting the bug. Two AI reviews argued about it; a forty-line probe settled it.
TL;DR
- My open-source video QA tool timestamped every on-screen event half a sampling interval early — a systematic bias, not jitter, hiding in an ffmpeg default.
- The bug had a bodyguard: a test I had written from a plausible but unmeasured explanation locked the wrong behavior in as the expected one.
- Two AI code reviews read the same lines and returned opposite verdicts. A forty-line probe video, where every frame's brightness encodes its own index, settled it in one run.
- One ffmpeg option — round=up — fixed eight modules at once. The correction is released as vidqa 0.2.0, and the rewritten test now guards the measured truth.
aitestingverification
DATE2026-08-20READ5 MINSLUG/half-a-step-early
14
The law shipped first
Seventeen days after the EU began requiring labels on synthetic audio, I shipped twenty-six unlabeled AI narrations. Nothing in my pipeline objected. So I built the thing that objects.
TL;DR
- On August 2, 2026 the EU began requiring that AI-generated audio be disclosed. On August 19 I shipped an AI voice reading every post on this site, labeled nowhere. No tool in my pipeline knew to object.
- The fix is an auditor in three parts: a dated rulebook only a human may change, a script that fails the deploy when a required disclosure is missing, and a small ledger stamping every AI-made artifact with the rule version it shipped under.
- First run against this site: 54 blocking findings. After the fix pass: zero. Every narration now carries a visible label and a machine-readable mark in the file itself.
- When a rule changes, one command lists exactly which past artifacts shipped under the old version and need another look.
aicomplianceprocess
DATE2026-08-20READ4 MINSLUG/the-law-shipped-first
15
Where the tokens go
The plugin's benchmark was honest. It still lost me a thousand dollars. The bill was never about output.
TL;DR
- I priced eight weeks of my AI coding assistant's usage. 62 cents of every dollar went to the model re-reading its own setup — tool definitions, plugin instructions, rules — on every single request. The answers it wrote were only 7.6 cents.
- A popular token-saving plugin performs exactly as its benchmark claims, and still lost money: at most $240 of possible savings against $1,297 of overhead from the instructions it inserts into every conversation.
- Telling the model to 'answer concisely' backfired — answers came out 18 to 38 percent longer.
- The real lever is shrinking what gets re-sent with every message: connected tool servers, plugins, hooks, and long session histories.
aiinfrastructureprocess
DATE2026-08-19READ5 MINSLUG/where-the-tokens-go
16
Twelve pentagons
You cannot tile a sphere with hexagons alone. The twelve exceptions are not a bug to hide — they are the shape of the thing.
TL;DR
- A sphere cannot be tiled with hexagons alone — Euler's formula forces exactly twelve pentagons at any board size.
- Expose the exception in the interface: every cell answers is-pentagon, so five-neighbour cells become a playable feature instead of a smuggled edge case.
- Sphere pathing needs great-circle cost, and GDScript A* needs a hand-rolled binary min-heap (about thirty lines) to be A* at all.
gamesalgorithmgodot
DATE2026-07-13READ6 MINSLUG/twelve-pentagons
17
The hand is not the board
Everyone assumes the poker hands form on adjacent hexes. They do not. Getting that wrong would have welded the rules to the geometry forever.
TL;DR
- Poker hands are classified by ranks and suits only — board adjacency never decides whether a hand is a hand.
- That separation lets the same rules run unmodified on a sphere or a flat grid; fusing rules to geometry would weld every board change to poker.
- Map the thirteen ranks onto a cycle and the Ace-low straight stops being a special case.
gamesarchitecturealgorithm
DATE2026-07-13READ5 MINSLUG/the-hand-is-not-the-board
18
I see no rain
Every line of logic was correct. Both feature flags were right. Three hundred checks passed. The player saw nothing at all.
TL;DR
- Every unit of logic was correct and three hundred assertions passed — the player still saw nothing, because the effect node lived on the wrong screen.
- Composition bugs (right component, absent from the right screen) are structurally invisible to headless tests; no number of extra suites finds them.
- Headless tests, golden images, and a human playing are three different instruments; none substitutes for another.
gamestestinggodotglitchy
DATE2026-07-13READ5 MINSLUG/i-see-no-rain
19
The threads you cannot have
Godot's web export wants SharedArrayBuffer. SharedArrayBuffer wants headers your static host will not give you. There is a way out, and it costs you threads.
TL;DR
- Godot's default web export needs SharedArrayBuffer, which needs COOP/COEP headers your static host may never give you — and the failure looks like a black screen, not a header problem.
- The nothreads export variant runs the whole engine on the main thread: plain static files, zero header configuration.
- The cost is engine parallelism — invisible for puzzle and turn-based games, real for physics-heavy ones. A game that is a link gets played.
gamesfrontenddistributiongodot
DATE2026-07-13READ5 MINSLUG/the-threads-you-cannot-have
20
Tenancy at the database line
Multi-tenant isolation belongs in the database, not the application. One forgotten WHERE clause should not be able to leak another org's data.
TL;DR
- Tenant isolation lives in Postgres row-level security, not application WHERE clauses — the database itself refuses to return another org's rows.
- A policy suite plus a tenant-leak fuzzer fails the build if a single row crosses the boundary; a real org runs as the proof tenant.
- When a security property must hold everywhere, push it to the lowest layer that can enforce it for everyone at once.
saasbackendsecurity
DATE2026-06-24READ4 MINSLUG/tenancy-at-the-database-line
21
Two cards, no cloud
Image-to-video diffusion as a daily driver, run on consumer GPUs at home — where the trick is keeping the gaming card out of the lane.
TL;DR
- Image-to-video diffusion runs at home on two RTX 5060 Ti cards; the RTX 4080 stays pinned to gaming and is never preempted.
- The dispatcher watches per-card VRAM headroom and routes each batch to whichever card has room.
- Unmetered rendering changes behavior: when a render costs electricity instead of credits, you stop rationing and start experimenting.
aiinfrastructureownership
DATE2026-06-24READ3 MINSLUG/two-cards-no-cloud
22
Local-first by default
Running everything on hardware I own is not frugality. It is a design choice that changes what I am willing to build.
TL;DR
- Local models and owned GPUs mean cost that does not scale with use — an overnight agent fleet costs electricity, not an invoice.
- Privacy becomes structural instead of contractual: the data never leaves a disk you can see.
- The unpredicted effect: near-zero iteration cost collapses the 'worth a shot' threshold and widens what gets attempted at all.
ownershipaiinfrastructure
DATE2026-06-24READ3 MINSLUG/local-first-by-default
23
Functional core, thin bridge
The pattern under a chess engine, a casino, and two smart-glasses apps: keep the rules pure and push every side effect to the edge.
TL;DR
- Four unrelated-looking apps share one shape: immutable state, pure reducers, dumb views, every side effect quarantined in a thin bridge.
- Because the core is pure, G2 Balatro's entire game runs under 136 tests with no glasses in the loop.
- When the hardware is absent, a browser preview swaps in for the bridge — the platform becomes the last inch.
architectureprocesstesting
DATE2026-06-24READ4 MINSLUG/functional-core-thin-bridge
24
The opponent thinks on another thread
A chess AI that searches a tree deep enough to matter, without ever freezing the board it is playing on.
TL;DR
- The minimax search runs in a background isolate, so the board never freezes while the engine thinks.
- The rules engine cuts no corners: pins, checks, checkmate, stalemate, fifty-move, threefold repetition, insufficient material.
- One Flutter codebase covers Android and Windows; concurrency done right is a feature you feel and never see.
gamesalgorithmsconcurrency
DATE2026-06-24READ3 MINSLUG/thinks-on-another-thread
25
Forty panels, one function
An ops dashboard that runs as my wallpaper and never reflows on a data tick — because placing the panels is a pure function, not a hand-built layout.
TL;DR
- Forty-plus dashboard panels run as a live wallpaper on a 5120-by-1440 ultrawide, and a data tick never moves a box.
- Placement is a pure function: panels self-register as plugins and one deterministic packer lays out the twelve-column grid.
- Ambient mode suspends the heavy renderers so the wallpaper costs almost no GPU; focus mode wakes it into an interactive console.
frontenddesignsystems
DATE2026-06-24READ4 MINSLUG/forty-panels-one-function
26
The swarm on your face
Agent status and a push-to-talk assistant on a pair of smart glasses — which works because the glasses are the last inch, not the logic.
TL;DR
- Live AI-swarm status on a 576-by-288 monochrome glasses display: NOW, QUEUE, and STATS pages cycled by a temple tap.
- Double-tap starts push-to-talk: audio to transcription to a streamed reply, modeled as an explicit state machine the display walks you through.
- Page builders and state transitions are pure functions, fully testable in a browser with no glasses and no network.
hardwareaidesign
DATE2026-06-24READ3 MINSLUG/swarm-on-your-face
27
One zoom, no seam
A game that runs from one deckhand mining ore by hand up to an empire of fleets, with no loading screen between the scales.
TL;DR
- One continuous zoom from a deckhand hand-mining ore up to fleet-scale empire — no loading screen between the scales.
- Persistent theaters keep simulating whether or not you watch; attention, not combat, becomes the scarce resource.
- Movement is genuinely spherical: great-circle paths on procedural globes with no navmesh, backed by a unit-tested GlobeMath core.
gamesdesignsystems
DATE2026-06-24READ4 MINSLUG/one-zoom-no-seam
28
Owning the IP line
Shipping a game on Steam means owning every name in it. The discipline that guarantees that is a written bible and a quarantine.
TL;DR
- Every player-facing name lives in a written IP bible; if a name is not in it, it does not ship.
- Reference material from the games that inspired the work is quarantined out of the build and marked not-for-use.
- Ownership is a constraint you build under from the first commit — a day-one bible costs an afternoon; a borrowed name found at launch costs the launch.
ownershipgamesprocess
DATE2026-06-24READ3 MINSLUG/owning-the-ip-line
29
One line, one soundtrack
An audio-generation tool with three front doors, where the one that matters is the door a game build walks through to get a file path back.
TL;DR
- Game audio comes from a pipeline: request a track, poll the render, get a file path back — no sound library, no browser.
- One generation core, three front doors: a CLI, a local web UI, and the callable engine a game build invokes in one line.
- Failures pass the upstream message through instead of masking it — a pipeline feeding a build has to be honest.
pipelinearchitectureownership
DATE2026-06-24READ3 MINSLUG/one-line-one-soundtrack
30
Replacing the home screen
A launcher and a game that read as one product, because they share the same storage and the score shows up with no sync plumbing at all.
TL;DR
- A real HOME-intent launcher, not a pinned desktop — it becomes the device's shell.
- The score widget has no sync plumbing: launcher and game read the same key-value store, so a clear in the game updates the home screen.
- When you own both sides of a seam, do not sync — share the one source of truth both sides already trust.
androidownershipdesign
DATE2026-06-24READ3 MINSLUG/replacing-the-home-screen
31
The hive reported false-done
An AI swarm told me a game shipped. The game did not exist. The only status that counts is the one the repository agrees with.
TL;DR
- The crew board said a third card game shipped; the repository had no file, no commit, nothing on any branch.
- An agent's self-report is a claim, not evidence — 'done' is the cheapest token a model can emit.
- Every task now gates on artifact-anchored checks: owner approval, the real test command executing, independent verification, a visible diff.
- Make the repository, not the transcript, the source of truth.
aiprocessverification
DATE2026-06-15READ4 MINSLUG/hive-false-done
32
A swarm that builds games
The interesting part of an agent swarm is not that it writes code. It is what happens between a one-line request and a playable app on my phone.
TL;DR
- The loop that matters: a one-sentence request decomposes into tasks, parallel specialists build, a verifier gates on real tests, and a signed build lands on the phone.
- What separates shipping from looping is discipline: tight task contracts, verifiers wired to artifacts, escalation after honest failures, humans reviewing diffs.
- The payoff is threshold collapse: chess, a tower defense, and a card room each went from description to phone icon, several in one week.
aiprocess
DATE2026-06-15READ4 MINSLUG/swarm-that-builds-games
33
A roguelike on your face
Building a full Balatro for smart glasses, where the display is 576 by 288 pixels of monochrome and the only input is a tap.
TL;DR
- A full Balatro — thirty jokers, the real chips-times-mult scoring, shop, boss blinds, save and resume — on 576-by-288 monochrome glasses with tap-only input.
- A pure functional core makes it tractable: 136 tests run the whole game with no glasses in the loop.
- The tiny screen improved the design: a display that forbids decoration forces clarity about what the game actually needs to say.
designprocess
DATE2026-06-15READ3 MINSLUG/roguelike-on-your-face
34
Theming as a product
Most sites have a theme. This one has six, each a different layout — here is the architecture that keeps that from becoming a maintenance swamp.
TL;DR
- Six visual identities, each a genuinely different layout, all rendering one typed content source.
- Two layers that never touch: OKLCH token swaps carry the lighter themes; bespoke per-surface components carry the rich ones, wired by a registry with graceful fallback.
- The test of the architecture is that the seventh theme is free — content and presentation cannot rot each other.
designprocess
DATE2026-06-15READ3 MINSLUG/theming-as-a-product
35
A store of my own
Making small games was never the hard part. Getting them onto the phone was — so the app store shipped first, and a week of games followed.
TL;DR
- The bottleneck was never building games — it was the cable-and-adb dance to install them. So the private store shipped first.
- Publishing is one command from any project directory: build, sign, upload, catalog upsert. Finished Saturday, on the phone Saturday night.
- Cheap distribution changes what gets made: the glasses Balatro exists because trying it was nearly free.
ownershipprocessdistribution
DATE2026-06-14READ3 MINSLUG/a-store-of-my-own
36
Pair-designing with a stubborn senior
What it feels like to design a site with a tool that refuses to write code until it has interviewed you.
TL;DR
- The design tool interviews before it codes: audience, outcome, voice, and anti-references come before any pixel.
- Five visual directions were generated; one was chosen and four were deleted the same hour — optionality kept past the decision point is pure cost.
- The tool maintains a list of shapes that read as AI-generated and refuses them; the refusal is the actual deliverable.
designaiprocess
DATE2026-05-07READ5 MINSLUG/built-with-impeccable
37
The combination lock on the title screen
A match-three game with a hidden layer underneath. The seven cartridge sprites are an input device, not decoration.
TL;DR
- The seven title-screen sprites are an input device: tap sequences unlock hidden themes, mini-games, and a dev room.
- Nothing announces the lock exists; hints appear only after a first unlock, and they mislead on purpose.
- Four codes are in the post (Lucky 8s, Bit Rot, Tape Worm, Dev Room); the rest you find on your own.
glitchydesigneaster-eggs
DATE2026-05-07READ5 MINSLUG/jazzy-secrets
38
Eighteen sections, one guild
A guild site is supposed to be a forum and a calendar. We built eighteen surfaces because the work demanded it.
TL;DR
- Eighteen sections, each one replacing a Discord channel, a stale spreadsheet, or a note someone was tired of maintaining — never 'because guild sites have one.'
- Typed treasury categories took ten minutes to define and let any officer answer 'what did mining make last quarter' without a spreadsheet.
- Build the admin shape first and derive the member view from it; the reverse order cost a month of rework.
freedomguardsscopeownership
DATE2026-04-30READ6 MINSLUG/freedomguards-rebuild
39
Loud on purpose
Why this site looks like a transmission instead of a product page.
TL;DR
- Every visual choice does work: scanlines pace the eye, stripes carry signal, chromatic offsets do the job a gradient would do badly.
- Loud framing buys a dense, terminal-tight interior — people come for the vibe and stay for the work, in that order.
- Reduced-motion stops every animation, and the composition still reads loud — the volume comes from craft, not motion.
designprocess
DATE2026-05-06READ3 MINSLUG/loud-on-purpose
40
Swarms that ship
Three rules for running a small army of AI agents end-to-end without burning the house down.
TL;DR
- Phase the work — specification, pseudocode, architecture, refinement, completion — and give each phase one output the next can consume.
- Review the diffs, not the chatter: the patch is the only artifact that tells the truth.
- Pin AI work to the GPUs you can spare and keep the gaming card out of the lane.
aiprocess
DATE2026-04-22READ4 MINSLUG/swarms-that-ship

NOTES.

The heartbeat

When the test is the bug

Fifty-six models faced backwards

The harness was the slow part

The contract came first

Where the ripples went

Nothing merges on its own word

The probe that refuses to run

The crash was in the quit

No river runs uphill

The loop is the product

The second voice

Half a step early

The law shipped first

Where the tokens go

Twelve pentagons

The hand is not the board

I see no rain

The threads you cannot have

Tenancy at the database line

Two cards, no cloud

Local-first by default

Functional core, thin bridge

The opponent thinks on another thread

Forty panels, one function

The swarm on your face

One zoom, no seam

Owning the IP line

One line, one soundtrack

Replacing the home screen

The hive reported false-done

A swarm that builds games

A roguelike on your face

Theming as a product

A store of my own

Pair-designing with a stubborn senior

The combination lock on the title screen

Eighteen sections, one guild

Loud on purpose

Swarms that ship