Dice Lock adds new abilities, and branches now land through one tested queueDice Lock gains new abilities, and code changes get tested before they land

September 6, 2026 · Dice Lock gained two new abilities and per-speed Endless runs, and BigBrain job branches now get tested before they reach main.Dice Lock got two new special moves and speed choices for solo play, and automated code changes now get tested before joining the main version.

Dice Lock gets a forced-removal ability, and Endless gets a speed pick

Dice Lock, the dice battle game live at jiolab.dev/dicelock, picked up its third and fourth abilities today. Erase clears whatever the cursor is aimed at for a full meter bar, built on a new shared removal path, Board.removeDice(), that the day's other new ability, Row (a whole-row clear), also uses. A forced clear like these scores nothing of its own (no damage, no meter fill, no chain step, no gray die sent to the opponent), while whatever falls into the gap it leaves behind scores normally, which settles a design question left open since an earlier ticket. Erase also added a check so aiming it at an empty cell is refused outright instead of spending a full meter to remove nothing. Both were verified live in a browser, not just against the automated test suite.

Endless mode, the score-attack variant with no opponent, now opens a speed picker (Easy, Medium, or Hard) before a run starts, and the choice scales the whole rise curve rather than one number: Easy climbs at 0.7x Medium's rate, Hard at 1.3x, measured today at 0.09, 0.13 and 0.17 rows per second. High scores are now tracked per speed, since a slower climb makes for a longer run and a longer run scores more. One shared leaderboard would only ever have recorded whoever played slowest, so the existing high score was carried into the Medium slot rather than discarded. On phones, a swipe up on the board now raises the stack, routed through the same hold logic the raise button and keyboard already used, so it moves at the same speed for the same length instead of becoming a second mechanism that could drift out of step with the first.

A job branch is now tested and rebased in one place, not by the session that wrote it

On the BigBrain side, the pipeline that lands each Linear ticket's code used to ask two different things to rebase the same branch onto main: the integrator that merges it, and, as the last step of its own work, the session that wrote the code, because a conflict discovered after that session's process had already exited had nobody left to resolve it. The reasoning was sound; the placement wasn't. It put git history surgery inside an unattended session that had shell access and a time limit, and one session that hit a real conflict, resolved it correctly, then got stuck on git's commit-message editor and reached for a kill command to unstick itself, taking four unrelated sibling sessions down with it.

That rebase-and-test step is gone from what a session does to itself. The integrator alone now runs the repo's own test suite on the rebased branch before main moves, using the same command the fleet's own test runner would use. A red suite or a conflict leaves main untouched and dispatches one repair session into the same worktree, rather than routing the failure straight back to a human the way it used to. The lock a session holds during this grew wide enough to cover a full test run, and the wait for that lock now outlasts it, so a second branch queued behind a slow one doesn't give up and orphan itself.

Dice Lock gets a new special move, and its solo mode lets you pick a speed

Dice Lock is a dice battle game I built, live at jiolab.dev/dicelock, where you swap and clear dice on a grid to beat an opponent, or in solo mode, just survive as long as you can. Today it got its third and fourth special moves. The new one, Erase, lets you clear whatever square your cursor is on by spending a full special-move meter. It's built on a shared piece of code that a second new move, Row, also uses to clear a whole row at once. Neither move scores any points on its own (no damage, no meter refill, no bonus), but whatever dice fall into the gap they leave behind score normally, same as any other clear. That settles a design question left open from earlier work. Erase also got smarter: aiming it at an empty square now refuses to fire instead of wasting a full meter to remove nothing. Both were checked by actually playing the game in a browser, not just by the automated tests.

The solo mode, Endless, where you play alone against a board that keeps rising and try to beat your best score, now asks you to pick a speed (Easy, Medium, or Hard) before you start, and that choice changes how fast the whole board climbs, not just one setting buried in it: Easy rises at 0.7 times Medium's speed, Hard at 1.3 times, measured today for each. Your best score is now tracked separately per speed, because a slower climb naturally gives a longer run, and a longer run scores more. One shared best score would only ever have recorded whoever played slowest, so your existing best score was kept and filed under Medium rather than thrown away. On a phone, swiping up on the board now raises the stack of dice, using the exact same logic as the on-screen raise button and the keyboard, so it moves at the same speed for the same length instead of being a second way of doing the same thing that could quietly stop matching the first.

A piece of code now gets tested and combined with the main version in one place, not by the automated worker that wrote it

Separately, on the automation that runs my other projects: the system that takes a finished piece of work from an automated coding session and lands it in the main codebase used to ask two different things to update a branch with the latest main code: the central process that combines code, and, as its last step, the session that wrote the code itself. That second step existed because a conflict discovered after the session had already shut down would have nobody left to fix it. The reasoning was sound, but doing it inside the session wasn't: it meant an unattended, time-limited process was performing surgery on shared project history with full command-line access. One such session hit a real conflict, fixed it correctly, then got stuck waiting on a text editor that pops up to write a commit message, and tried to force itself unstuck with a kill command, which also killed four other, unrelated sessions running at the same time.

That step no longer happens inside the automated sessions at all. The central combining process now runs the project's own test suite on the updated branch before anything reaches the main version, using the same test command a human would run by hand. If the tests fail, or the code doesn't merge cleanly, the main version is left untouched, and instead of the failure going straight back to me, the system dispatches one more automated session to fix it in place. The waiting period a session holds onto its project folder during this was made long enough to cover a full test run, so a second piece of code waiting its turn doesn't give up while the one ahead of it is still being checked.