Developer Tools / ARTICLE

A Git Queue for Fighting AI Brain Fry

A developer moves AI coding tasks into a Git-backed priority queue and processes one item at a time to reduce context switching in terminal-based Claude Code and Codex workflows.

The failure mode in terminal-based AI work

Working with Claude Code or Codex from a terminal often leads to a familiar escalation. A task starts, the AI takes time to reply, so another task starts. The first reply arrives and asks for a clarification, a follow-up, and a side task, each in its own tab. Then the second tab’s reply lands. Before long, the developer is hopping between 20 threads, holding multiple contexts in working memory. At some point the brain gives out: focus shatters, and it becomes unclear what was being done, where it started, or where it should finish.

One developer’s response was not limited to taking breaks, thinking before typing, or restricting scope. He treated the problem as having two main defects: sequencing and context. The fix was to organize work like a priority queue.

Tickets in Git, decisions in an owner inbox

The queue lives in Git. Every ticket is a Markdown file in the repository, next to the code it concerns. The board state is a committed snapshot. Nothing important lives in a chat window or in the developer’s head; if a session dies, the queue remains.

An agent works the board in cycles. It researches new tickets, builds the ones a human has tagged as safe to build, runs tests and a browser check, and verifies what is already deployed. For work touching sensitive code, it builds on a branch and asks first. It never deploys to production; that part stays with the developer.

What the agent cannot do is decide. Everything requiring the developer’s judgment lands in one place called the owner inbox. A script reads the whole board and produces a prioritized list of items waiting on a decision: review this change, answer this question, rule on this tradeoff.

The reading surface is a Claude artifact. Rebuilt from Git on every cycle, it mirrors the whole board and includes a review page for each ticket. Instead of scrolling back through a terminal to reconstruct what a change does, the developer opens one link, reads what was built and why, and records a verdict. The verdict goes back into Git, onto the card. The page is only a viewer; Git is the record.

Closing one card at a time

The most important step comes next. The developer takes one item, loads its context, makes a decision or requests an action, and closes it by putting it back into the queue. That closing is the whole trick. The ticket stops hanging in memory as something to remember. The context closes with it, so the next item from the queue can be picked up with actual focus. One thing at a time.

This is still exhausting, but the developer reports feeling less distracted and less lost. The ongoing challenge is the tooling around the system: serving context in a digestible way so loading a ticket takes a minute rather than twenty, and keeping tickets from entering endless loops because they are blocked on a ruling only the developer can give. He describes the setup as a living system that keeps improving, and for him it marked a major step forward in productivity with AI tools.

END
Feedback