Moving a ticket to Todo in Linear now starts the agent work on itApproving a task in my project tracker now starts the AI on it by itself

September 9, 2026 · Moving a Linear ticket to Todo now starts agent work on it, closing a hole that once let 21 unapproved tickets run all at once.My project tracker now starts AI work once I approve a task, closing a gap that once let 21 unapproved tasks all start at once.
last updated

Moving a ticket to Todo is what starts the automated work on it now

BigBrain, the agent system that does most of the work behind this site's projects, used to need me to hand-delegate every chain root myself: about 480 tickets a month, one click apiece. Automated dispatch had been tried before and pulled back: a sweep called triageSweep.js was deleted on 2026-09-01 after it started 21 tickets I had filed only as a plan and explicitly said must not run, within four minutes of an unrelated guard being loosened. The bug wasn't a missing check. It was that "not yet" had nowhere in Linear to be written down, so the ticket's assignee field was standing in for approval, and lifting one assignee guard was enough to start all 21 at once.

Today's fix gives "not yet" somewhere real to live: Linear's own workflow states. Every filing route now lands a new ticket in Backlog, and nothing ever reads Backlog. Moving a ticket to Todo (the same drag I already did by hand to mean "start this") is the approval, and a five-minute sweep now dispatches every unheld, unblocked ticket sitting there. It matches by the state's type, not its name, so renaming a column later can't reopen the old hole. Hand-delegating still works exactly as before; the sweep just means it's usually no longer necessary.

A same-day follow-up caught a second bug in the same code: the availability check and the dispatch logic disagreed about which of three roles counted, so roughly 84% of the time, the common case, the sweep spent a classification call and then failed to dispatch anyway. A related fix stopped voice and Telegram filings from misreporting the new behavior: they'd been saying "assigned to BigBrain" for tickets that were actually sitting in Backlog, held by nobody, waiting on exactly this approval.

Separately: a finished Dice Lock run can be watched back, and Railway stopped crying wolf

Until today, finishing a run of Dice Lock, my dice battle game, meant the result screen and then nothing. The game now saves every finished run on-device, up to 25 of them, and gives you a History screen to browse: tap a row and it opens on the game's real board, with play and pause, instead of a stat line. What gets saved isn't a video, it's a recipe (the seed the run started from, the settings, and the timestamped list of everything the player and the built-in opponent did), and replaying it means feeding that back through the same engine a live game runs on.

That claim only means something if the replay actually lands where the original did, and today's other change proved it does: a script drives a real headless browser through an entire match played three separate ways (keyboard, touchscreen taps, and a fake gamepad), then replays each recording and checks the result, duration, and the eleven separate counters the engine keeps against what actually happened. Measured today: a 5,067-millisecond match replays to the same loss, by the same cause, at the same 5,067 milliseconds.

Separately, Railway had sent "Deployment crashed" emails for both Dice Lock and Reckreation, my pickup-basketball scheduler, for ordinary redeploys that hadn't actually crashed. Every redeploy sends the outgoing container a SIGTERM, Node's default handler answers by exiting non-zero, and Railway reads any non-zero exit as a crash rather than a routine replacement. Reckreation's fix landed in one pass (exec the process directly and exit 0), and checking Railway's own history afterward showed zero real failures across 106 deployments since September 2nd. Dice Lock needed two: the first pass added a handler that exits 0, checked against 60 of 60 recent deployments reading clean, but the very next replaced deployment still crashed anyway, because npm was running the process inside a shell that died without forwarding the signal. Making npm exec Node directly, so the signal reaches the handler at all, was the second pass, verified locally against the same failure.

Approving a task in my project tracker now starts the AI on it by itself

BigBrain is the system of AI agents that does most of the work behind my side projects. Until today it needed me to hand off every top-level task myself, about 480 a month, one click each. I'd tried letting it start work on its own before and had to turn that off: code that automatically swept up tasks and started them was deleted on 2026-09-01, after it grabbed 21 tasks I had only written down as a plan and specifically said must not start yet, all within four minutes of an unrelated safety check being loosened. The problem wasn't a missing check. It was that "not yet, I'm still deciding" had no way to be recorded, so the system used "who's it assigned to" as a stand-in, and loosening one unrelated check started all 21 tasks at once.

Today's fix gives "not yet" a real place to live: the status columns my project tracker already has. Every new task now lands in a "Backlog" column that nothing reads automatically. Dragging a task into "Todo", the same thing I already did by hand to mean "go ahead", is now the approval itself, and every five minutes the system checks that column and starts anything sitting there. It recognizes columns by their underlying type, not their name, so renaming one later can't reopen the hole. I can still hand off tasks the old way; usually I no longer have to.

A fix made later the same day caught a second bug in this new code: one part checked who was available and a different part assigned the work, and the two didn't agree on how to count. About 84% of the time, the common case, the system spent effort figuring out who should do a task and then failed anyway. A related fix stopped my voice assistant and messaging bot from announcing something untrue: they'd been saying a task was "assigned to BigBrain" when it was really sitting unassigned, waiting for approval.

Separately: my dice game can save and replay a finished game, and a hosting service stopped crying wolf

Until today, finishing a game of Dice Lock, the dice battle game I built, meant seeing the results screen and then losing the record of it. The game now saves every finished game on your device, up to 25 of them, on a new history screen: tap one and it opens on the game's real board, with play and pause controls. What gets saved is more like a recipe than a video (the starting setup, the settings, and a timestamped list of every move made), and playing it back means feeding that recipe into the same engine that ran the live game.

That's only useful if playback matches the original exactly, and that's what got checked today: a script drives a real browser through a whole game automatically, three separate ways (keyboard, touchscreen taps, and a fake controller), then plays back each recording and checks it against what actually happened, statistic by statistic. Measured today: a game that took 5,067 thousandths of a second played back to the identical loss, for the identical reason, at the identical time.

Separately, the hosting service behind both this dice game and Reckreation, my pickup-basketball scheduler, had been sending "your app crashed" emails for routine updates that had not crashed. Every update briefly shuts down the old running copy by sending it a signal, and the code was answering with an error exit, which the host reads as a crash rather than a normal handoff. Reckreation's fix worked in one try (run the process directly instead of through a wrapper, and exit cleanly), and the host's records afterward showed zero real failures across 106 updates since September 2nd. Dice Lock needed two tries: the first exited cleanly and checked out fine across 60 of 60 recent updates, but the very next one still showed as crashed, because the signal was reaching a wrapper program that died without passing it to the game server. Skipping that wrapper was the second try, and it held up.