Most of my day happens inside an app called T3 Code. It's an open-source control plane for coding agents, which is a slightly grand way of saying it puts Claude Code, Codex, Cursor, Grok and the others on one screen, using the subscriptions I already pay for. Every task I hand to an agent becomes a thread. The thread remembers which model I picked, which files it touched and what we said to each other, and it keeps running on my machine after I close the window. At any given moment I have a dozen of these going across different projects, which is exactly why I needed something to hold them all. T3 Code explains the product properly. This note is about the one habit I've built on top of it.
The desktop app looks like this: threads down the left, the conversation in the middle, the diff on the right. The picture is the one from the t3.codes homepage.
T3 has its own guide to that list, Working with threads, which covers pinning, settling, snoozing and a section called Working. All of that is good as it is. What I add is a way of deciding what to do with the list, because without a rule it turns into the same pile of open tabs I was trying to get away from.
The first thing I do is switch on the Working section, under Settings and then General. With that on, the moment I send a message to a thread it drops out of the active list and waits under Working while the agent is busy. It only comes back to the top when something has actually happened: it finished, it failed, or it needs me to approve something or answer a question. Threads I've pinned stay where I pinned them. T3 describes this under Fold working threads.
Once that's running, my job gets a lot smaller, because I don't have to scan the whole list anymore. I look at whichever thread has just come back to the top, and I give it one of three answers.
If one more message would turn it into something I'd actually ship, I write that message and the thread drops back into Working. If I know I wouldn't open it again tomorrow, I settle it, which keeps the conversation around but takes it off the list. And if I can name the hour when it will matter again, I snooze it until then. A snoozed thread stays hidden while the agent keeps working, and it comes back early if it needs me or the run fails.
Then I move on to whatever is on top now. I've stopped sorting the list or dragging rows into an order I like better, because while Working is on the order is simply the order in which threads came back to me, and that turns out to be a better priority queue than anything I'd build by hand. A snoozed thread that wakes up while its agent is still busy goes back under Working rather than jumping the line, and a pinned one that wakes up goes back to its pin.
What I like about this is that the agent does all the preparing inside the thread, and I still decide what happens next. It's the same rule I wrote about in The person still decides, applied to a list instead of a single file.