Smaller steps, more lanes: running six AI coding agents<br>Open search (press Control or Command and K)Toggle themeWrite

Command Palette<br>Search for a command to run...

PPablo Curell Mompo

div>p:first-child]:mt-0 [&>div>p:first-child]:pt-0 min-w-0 wrap-break-word [&_a]:break-all **:max-w-full">Remember when I told you all I'd swim in one lane? Well... I'm swimming in two to six lanes now. And I can report that my deploy paralysis is gone, and that my mental fatigue doesn't kick in meaningfully until the end of the day.

Which means either I've learned nothing at all, or something changed in between.

For those who missed it (or didn't want to follow a link on the first sentence of an article): I'd had five projects going at once, my nervous system was fried, I was saying yes to everything without even looking, and it took me about a month to dig myself out of the PRs that came back. I concluded that we have to do less. Well, now I can juggle two to six tasks at once.

The models might have gotten marginally better, but that's not what changed. I was right that I had to do less, but I had the wrong unit. The problem was how much I was asking the model to do in each stride. And by lowering that amount I can keep more things in parallel actually moving.

Before any of the specifics, the thing all of it is built on.

So what is a stride?

A stride is the smallest thing I can ask for that gets me in the right direction from green (passing tests) to green. I do have a final destination in mind, and I share that with the model, but a stride is really the smallest directionally correct step I can take. In practice that's usually one behaviour, and the test that drove it.

Of course, I'm building on the shoulders of giants here, and GeePaw Hill's Many More Much Smaller Steps is what inspired this. Stop here and go read that, I'll wait, and it's worth it! The final trigger was a conversation we had on A Junior, A Senior and I with Tim and Paul.

I'd rather bound a stride by time, the number I care about is the minutes between meaningful interactions. But the model can't feel time. If I ask it for "about ten minutes of work", it hands me a feature. It can count lines though, and 40 is a size it can both hold and check itself against.

Here's the shape of one. Say I want a report to leave a blank rather than a zero when there's nothing to measure yet. The test comes first:

test "reports no median for a step where nothing was paid" do<br>report = EffectivenessReport.new(rows: [step_with_no_payments])

assert_nil report.rows.first[:median_days_to_payment]<br>end

And then the change that makes it pass:

- median_days_to_payment: row["median_days_to_payment"].to_i<br>+ median_days_to_payment: row["median_days_to_payment"]&.to_i

You'll notice that this stride is quite small. Not all of them are like that, but I want to stress that a stride is not necessarily a feature, it can be as small as a three line change. Most are around 40 lines, but I don't have many 200+ line diffs anymore. One stride is one commit.

Once the stride is done, it's up to me to decide where we're going next (although the word generator sure likes to make "suggestions").

But how do you run six at once?

One stride at a time is easy when you're in one lane. The reason I can be in six is that opening a lane costs me nothing.

claude-dev task opens a tab, creates the worktrees if they don't exist, and lays out four panes: a claude session on the left, resumed if one already exists, and shells on the two worktrees and their shared parent on the right. It's tmux inside Ghostty, and you can probably reproduce it with other tools. That's the whole thing — I'm not really in need of a helicopter view.

I'll usually have two to six of those running. One of them is my actual priority. The others are things that need less attention from me: migrating legacy code, migrating specs. Sometimes something small someone asked for, a graph, some quality of life thing. When a new thing pops up, I reach for claude-dev task and pick the first stride.

Once a stride is done I get a notification, and I open the tab to be greeted by the diff. On the whole I'm interacting meaningfully with each task every 5 to 10 minutes, and each interaction lasts anywhere from 30 seconds to 5 minutes.

I'm steering the system, and yes, that's context switching all day long. The difference is what a context costs now: 40 lines and the test that drove them, instead of a whole branch I have to rebuild in my head.

The part I won't hand off

This is the part I don't want to hand off. The model is bad at it.

When a stride lands, two things arrive with it: the diff, and a suggestion for what to do next.

The review pane gives me the files that changed, a map of what else in the codebase references them, and then the diff itself. That's enough to see whether it's doing what I asked, and to the standard I expect. Since it's small, I can go through it quite easily and fast, and it doesn't take much out of...