The bottleneck moved upstream

You type “pick up the next batch” and the room goes quiet for forty minutes. Somewhere on disk, four worktrees are filling with code you didn’t write. The terminal you’re sitting in front of has nothing to show for it. The session that used to do the typing is doing something else now - holding the shape of the work, watching for collisions, committing the diffs that come back clean.

The quiet isn’t idle. The work is happening with full intensity, just not where you can see it. What used to be the whole job - pressing keys to produce code - has compressed into a sentence and a wait.

The work didn’t go away. It moved.

What got cheap

The mechanics are concrete enough to name plainly. Claude Code running on a plan-mode loop. Subagents and agent teams holding the implementation, ephemeral context windows opened and closed as tasks come and go. Git worktrees so the agents don’t collide on shared files. An MCP server connecting all of it to a task board that holds the source of truth. The orchestrating session doesn’t carry the work itself; it picks up batches, hands them off, and writes the result back.

The substantive cost of typing-the-code has fallen to roughly the cost of describing-the-code well. Anyone who has run an agent on a worktree for an afternoon has felt this. When one input gets cheap, attention naturally flows to whatever sits next to it that hasn’t gotten cheap yet. That’s where the work goes now.

What got expensive

Architecture. Sequencing. Scope. The decisions about what a piece of work even is - where it begins, where it ends, what it touches, what has to be true before it can begin at all. Decisions that used to amortize across weeks of typing now resolve in an afternoon. The wrong ones do too. A vague task no longer means slow progress; it means confident progress in the wrong direction, with a clean commit history attached.

There’s a hard ceiling underneath this if you don’t decompose well. Claude’s context window softens somewhere around 250,000 tokens, and long-running sessions that try to carry the whole project in their head will drift regardless of model. The work has to come in pieces small enough to fit cleanly in a fresh session, with enough surrounding context that the agent can do its job without asking. That decomposition is yours. It’s also, increasingly, where the day’s actual thinking happens.

Planning stops being the thing that precedes the work. It becomes the work.

The board as the surface

When the doing moves to the agents, the kanban stops being a ledger of what’s done and becomes the surface where the work is shaped. You stop writing code. You start writing tasks - their shapes, their order, the conditions that have to hold around them. The board is no longer something you glance at on Monday mornings. It’s where you live during the day.

This pulls the columns away from status and toward phase. You don’t need a “started” column when agents start and finish in the same forty-minute window. You need to know which phase of the project a piece of work belongs to: schema, endpoints, integration tests, ready. Status is what an agent reports. Phase is what a human decides. Between phases sit gates with criteria - tests green, multi-replica behaviour verified, perf budget met. The gate is what you watch. The spans between gates are what the machine eats.

The board we use is Balladic, partly because its MCP server gives every session - main, subagent, agent team - the same live view of the same state. Whatever board you reach for, the point is the same. The kanban becomes a workshop you stand in, not a wall you check.

What shrinks, what grows

The picture that keeps surprising us is the inversion. The terminal, once the dense busy thing, mostly waits. The board, once a quiet ledger, fills with motion. Subagents work in parallel on isolated worktrees and never see each other’s files. The orchestrating session stays cool by doing very little - it picks up batches, watches for clashes, commits what comes back clean, and writes the state back to the board. The human moves between fresh sessions for thinking and the board for shaping. The keyboard cools.

The day starts to look different. You spend three hours on a plan and twenty minutes at a terminal and ship more than you used to ship in a week. The thing you carry in your head all day is no longer the next ten lines of code. It’s the next ten decisions about what the project should be.

What this changes, quietly, is which skills compound. Not speed at the keys - that ceiling stopped mattering. The patience to decompose a project into pieces an agent can hold. The discipline to write gates that mean something. The taste to notice when a phase is missing, when a task is too large, when the order is wrong. These were always the things that separated architects from typists. They just used to take a back seat, because the typing was the bottleneck.

Turns out the planning was never preamble. It was the job. We just had so much typing in the way we couldn’t see it.