How I'm fighting the AI Brain Fry — Sergey Kuhne
The author describes how juggling 20 parallel Claude Code or Codex threads wore out their focus, so they built a system where tickets live as markdown in git, an agent works the board in cycles, and the author only handles a prioritised inbox of items needing human judgement. Each ticket is closed out when it is decided, so context does not pile up in memory.
- The core problems are sequencing and context: running many agent threads at once overloads working memory, and the author treats that as the real failure mode.
- The agent researches, builds safe tickets, runs tests and browser checks, and works on branches for sensitive code, but never deploys to production. The human keeps that step and every judgement call.
- Each ticket is closed by writing the verdict back into git and returning the item to the queue, so only one decision is open at a time. The author says it is still tiring but no longer leaves them distracted or lost.
Sergey Kuhne's problem is one a lot of people who run Claude Code or Codex in a terminal will recognize. You kick off a task, the agent is slow, so you start another. Replies come back needing a clarification, a follow-up, a side task, and each one wants its own tab. Before long you're juggling around twenty threads and your focus gives out. He frames the root causes as two separate issues: sequencing (what to work on, and in what order) and context (keeping track of where each thread stands). Taking breaks and limiting scope were the standard advice, but he wanted something structural.
His fix treats work like a priority queue stored in git. Every ticket is a markdown file sitting in the repo beside the code it describes, and the board's state is a committed snapshot, so nothing important lives only in a chat window or in his head. An agent cycles through the board: it researches new tickets, builds the ones he has tagged as safe, runs tests and a browser check, and verifies what's already deployed. Sensitive changes go onto a branch and wait for approval, and the agent never deploys to production, which he keeps for himself. Anything requiring a human decision goes into what he calls an owner inbox, a script-generated, prioritized list of items waiting on his judgment. The reading surface is a Claude artifact rebuilt from git every cycle, giving him one page per ticket with what was built and why, so he can review and record a verdict without reconstructing anything from terminal scrollback. The verdict goes back into git, and the page is only a viewer.
The habit that matters most, in his telling, is closing each item fully. He takes one item, loads its context, makes a decision or requests an action, then puts the ticket back in the queue, so the context is closed along with it instead of lingering as something to keep remembering. That's what lets him focus on one thing at a time, though he's clear it's still tiring. The hard parts, by his account, were tooling: getting context served in a form that takes a minute to load rather than twenty, and stopping tickets from looping while they sit blocked waiting for a ruling only he can make. He describes the system as a work in progress that still feels like a big jump in his productivity, which is why he wrote it up.