A kanban board worked by AI agents

Most of the code on this domain is written by AI coding agents. Not "autocomplete with extra steps" — agents that claim work off a kanban board, do it end-to-end, and hand it back for review. The board is the interesting part, so that's what this post is about.

Cards are the contract#

Work enters the system as a card: a title, a description of why, and acceptance criteria that say what done means. That last field does most of the heavy lifting. An agent picking up "Add overdue indicators to the board" with criteria like "overdue cards show their due date in red; the filter bar can isolate them; tests cover the date logic" doesn't have to guess where the finish line is — and the reviewer doesn't have to reverse-engineer intent from a diff.

Vague cards produce vague work from humans too. Agents just fail faster, which turns out to be a feature: a badly specified card gets bounced with a question instead of becoming a week of confident wrong code.

Claims are leases, not assignments#

When an agent asks for work, it doesn't get assigned a card — it gets a claim with an expiry. The claim is a lease: hold it, heartbeat it while you work, and if you vanish (crash, context limit, network) the lease expires and the card goes back to the queue for someone else. No card is ever stuck "in progress" behind a worker that stopped existing an hour ago.

Expiry isn't free, though. A lease that times out counts as a strike against the card, and three strikes park it in a needs-human column. The pattern of failures matters more than any single one: a card that burned three agents is almost never an agent problem. It's a card problem — wrong scope, missing context, or a hidden dependency — and a human needs to see it.

Questions park the card#

The single best mechanic on the board: an agent that hits a genuine decision point doesn't guess and doesn't grind. It posts the question, the card moves to an awaiting-input column, and the claim is released immediately. The agent moves on to other work; I get a notification; my answer puts the card back in the queue for whoever claims it next.

This sounds like bureaucracy until you've watched an agent burn an hour elaborately satisfying an assumption nobody wanted. The cheap, honest "should this be X or Y?" beats both options.

Agents never close cards#

Completing work moves a card to in review — never to done. The gates before that are mechanical: types, lint, tests, coverage thresholds, dependency boundaries, all of it enforced by tooling that doesn't care how confident the author sounded. The gate after it is me. Agents propose; humans close. Every line still gets read before it ships.

That division has held up better than I expected. The machines are good at the part where effort is the bottleneck. The human stays load-bearing exactly where judgment is: what to build, whether it's right, when to ship.

Why a board, and not a chat#

A chat session is a workspace; a board is a system of record. Cards survive context windows. Comments and events leave an audit trail of who did what and why. Strikes surface bad cards. Leases make worker failure boring. None of this is novel — it's how good teams already run — which is exactly the point. The fastest way to make agents productive wasn't inventing new process. It was giving them the same one that works for people, with the rules enforced by software instead of etiquette.