Twenty Terminals Open, and No Idea Which One Needed Me

I had twenty Claude Code sessions running at once. Not a metaphor, not “a lot” — twenty. One repository in this window, another project in that one, a client’s platform in a third, four more tabs for things I’d half-forgotten I’d even started. Terminal windows stacked behind terminal windows.

And at some point I caught myself doing the same dumb loop over and over: click a tab, read three lines, no idea if it’s waiting on me or still working, click the next one, same thing, click the next one. Twenty times. Then start again, because by the time I got to the last one the first one had probably changed state.

That’s the moment it actually broke. Not the code. Me.

Twenty sessions and my attention is the bottleneck

Here’s what nobody tells you about running this many agents at once: the agents are not the problem. Claude Code chugs along fine on twenty things in parallel — that part scales. What doesn’t scale is a human clicking through twenty terminals trying to guess which one is stuck.

Some of those sessions were sitting there finished, just waiting for me to say “yes, do it.” Some had hit a question and were quietly blocked for an hour because I hadn’t scrolled up to see it. Some were still working, and I was interrupting them for nothing, just to check. I had completely lost control of the thing I was supposedly running. Not because the work was too hard. Because I couldn’t see the state of my own sessions without paying for it in clicks.

I already wrote about the actual code side of running many sessions at once — worktrees, so they stop fighting over the same files. That problem, I’d solved. This was a different one. Worktrees keep the sessions from colliding. Nothing was keeping me from drowning in them.

I loved Cursor. I just needed way less than that.

Before this I’d used Cursor a lot, and I mean that — I liked it. It’s a good product. Full editor, its own terminal panel, all the file-tree context you’d want, one place for everything.

But two things kept nagging at me. First, I wanted my own terminal. The real Terminal.app, the one I actually configured, not an emulation living inside somebody else’s editor. Second, and this one was harder to ignore: Cursor was eating a lot of memory. Every session, every panel, every embedded terminal, it all adds up, and I was already running enough processes at once that I didn’t need an editor competing with them for RAM.

So I cancelled the Cursor subscription. I also stopped opening VS Code, which is the editor Cursor is built on top of anyway — if I wasn’t using the fork for the reason I liked it, there was no reason to keep the original around either. Today I don’t open either one. Just my terminal, and the board I ended up building to watch it.

That’s not a complaint about Cursor. It’s a good product for what it’s built for. I just worked out that what I needed wasn’t an IDE. What I needed was something that could tell me, at a glance, which of my terminals wanted me.

A card is the color of its status. That’s the whole board.

So I built one. It’s called k0. It’s a board in the browser, one column per repository, one card per piece of work. You open it at k0.localhost:4319 and it just sits there, next to everything else.

The thing I’m proudest of is also the simplest decision in the whole tool: you don’t pick a card’s color. The card is the color of its status. No labels to assign, no manual triage, nothing to remember to update. Seven statuses, and the board sorts itself by how urgent each one is:

Red is Needs answer — it’s asking you something right now. Amber is Needs approval — it finished a plan and wants your yes. Yellow is Your turn — the terminal’s just sitting there idle. Blue is Working. Light blue is Planning. Grey is Backlog. Green is Done. The first four are on you. The two blues are the agent’s move, not yours — you don’t need to look at those at all.

Double-click a card and the real terminal window comes to the front, even if it was minimized behind six others. That’s it. That’s the whole interaction.

It doesn’t replace your terminal. It just knows where it is.

Here’s the part I want to be honest about, because it’s the part that makes this different from “another dashboard”: k0 embeds nothing. No terminal emulator, no PTY, no hooks bolted onto Claude Code. It drives the real Terminal.app through AppleScript — tmux if you’re on Linux, Windows Terminal on Windows — and it works out what state each session is in by reading files Claude Code was already writing anyway: ~/.claude/sessions/<pid>.json for live status, and the session transcript to know if you’re sitting inside a plan. Sessions in k0 are born in plan mode, always — that’s the one opinion the tool has about how you should start.

Every card also shows how much memory that session’s process subtree weighs. That one’s personal — it’s the direct answer to the Cursor complaint. I wanted to see the cost, not just feel it in a fan spinning up.

There’s a menu-bar icon too, and it takes the color of whatever card is most urgent across the whole board. Nothing waiting on you? It’s just an outline. It doesn’t try to catch your eye when there’s nothing to catch it for.

One detail I’m oddly fond of: k0 has four modes for how awake your machine needs to stay while sessions run, because caffeinate — the command basically everyone running long agent sessions leaves on in a spare tab — only blocks sleep from inactivity. Close the lid, and the sleep that fires from that goes straight past it. Anyone relying on caffeinate to keep working with the lid shut is relying on a wrong idea of what that command does.

It has zero npm dependencies. It makes no network requests at all — not one, not even to load a font. No telemetry, no account, nothing phoning anywhere. It doesn’t need to. All it’s reading is already on your disk.

Sometimes reinventing the wheel is the right call

I built it in about two weeks. Seventy-four commits, one person. Not because I don’t respect the tools that already exist — I used one of the best ones for months. But because what I actually needed, underneath all of it, was a post-it note. A way to see the state of a thing. A way to know it still remembers what it was doing. A way to keep the machine from falling asleep on it. A way to open a real terminal and then do whatever the hell I want inside it. A way to see which files changed, without opening a whole editor to ask.

None of that needed an IDE. It needed a board.

It’s free, it’s MIT-licensed, and you can have it — npx k0-board and you’re looking at your own sessions in a few minutes.

I still have a lot of terminals open. I just don’t click through them anymore to find out which one’s been waiting for me. I glance at the board, and it tells me.

So go and take it. And then tell me what you think — especially if it breaks on your machine, because that is the part I cannot test on my own.