TL;DR
Get business pricing on tech for your team
- Business-only prices and quantity discounts
- Tax-exempt purchasing
- Multiple users, one account, clear invoices
A developer’s account describes a workflow for managing coding-agent tasks through Markdown tickets stored in Git, a prioritized human-review inbox and one-task-at-a-time decisions. The writer says the system helps reduce distraction and lost context, but remains exhausting and requires ongoing tooling work.
Developer Sergey Kuhne describes using a Git-backed task queue to manage work with coding agents such as Claude Code and Codex, replacing a pile of terminal conversations with tickets, a prioritized review inbox and one-at-a-time decisions. In a personal report titled “How I Fight AI Brain Fry,” Kuhne says the approach helps him feel less distracted and lost, while acknowledging that the work remains exhausting and the system still needs refinement.
Kuhne’s account begins with a familiar problem of parallel AI conversations: while one agent is working, a user starts another task, then must handle replies, follow-up questions and side tasks across multiple terminal tabs. He says the resulting thread switching makes it hard to remember what he was doing and what should happen next. His response is to treat the work as a priority queue, with each ticket stored as a Markdown file in the project repository, near the code it concerns. The queue’s state is committed to Git, so the record survives a lost session and does not depend on a chat window or memory.
In the workflow he describes, an agent cycles through the board: it researches tickets, builds items a human has marked safe to build, runs tests and a browser check, and verifies work that is already deployed. For sensitive code changes, the agent works on a branch and asks for approval. Kuhne says it does not deploy to production; he retains that responsibility. Tasks requiring his judgment are collected in an “owner inbox”, where a script presents items such as code reviews, questions and trade-offs in priority order.
A Claude artifact provides a single reading page, rebuilt from Git on each cycle, with a view of the board and a review page for each ticket. Kuhne says the page is a viewer, not the record: decisions are written back to the ticket in Git. His central practice is to pick one item, load its context, make a decision or request an action, and then put the item back into the queue. He says closing out that step helps keep its context from lingering in his memory while he moves to the next task.
Reducing Context Switching in AI Work
The report is a personal workflow account, not a controlled study or evidence that the method works for every developer. Its relevance is practical: coding agents can make it easy to start multiple tasks at once, but people still have to review results, answer questions and make decisions. That can shift the burden from writing code to tracking parallel work.
Kuhne’s system separates the agent’s work from decisions that need human attention. Keeping tasks and verdicts in Git gives those decisions a durable record, while the inbox is intended to make the next human action easier to find. For readers using coding agents, the account offers a concrete approach to organizing work without treating every open chat as a task list. It also makes clear that workflow structure does not remove fatigue: Kuhne says he still finds the work exhausting.
Products Worth Considering
Sony WH-1000XM4 Wireless Noise-Canceling Headphones, Silver
Jackery HomePower 3600 Plus Portable Power Station, 3584Wh, 3600W
Samsung Galaxy Tab A11+ 11-Inch Wi-Fi Tablet, 6GB RAM, 128GB Storage, Gray
As an affiliate, we earn on qualifying purchases.
From Terminal Threads to Git Tickets
Kuhne frames the problem around using Claude Code or Codex from a terminal, where each task and follow-up can create another conversation or tab. His proposed change focuses on two issues he identifies: sequencing work and preserving its context. Rather than relying on a user to reconstruct a task from chat history, the queue puts the work and its state in the repository.
The division of responsibility is also part of the design. Agents can research and carry out work that has been marked safe, while the human handles approvals, sensitive changes and production deployment. The review page brings the material together, but Git remains the source of record. This is the workflow Kuhne reports using; the post does not establish how broadly it has been adopted or how it performs compared with other approaches.
“The queue lives in git.”
— Sergey Kuhne, in “How I Fight AI Brain Fry”
Limits of Kuhne’s Workflow Account
The source is a single developer’s account and provides no measured results, comparison with another workflow, or evidence about how the system performs for other users. It does not quantify changes in productivity, task completion time or fatigue. Kuhne describes the setup as an ongoing experiment, so its longer-term effects are not established.
Some operational details are also not specified, including how the queue’s prioritization rules work, how often the agent cycles, or how the workflow handles errors beyond tests and a browser check. Kuhne says tickets can enter endless loops when they depend on a ruling only he can provide, and that presenting context quickly remains a challenge. The report does not describe a release plan or provide independent verification of the workflow’s results.
Further Changes to the Queue
Kuhne says the system is a work in progress and that he continues to improve it. The problems he identifies for further work are making each ticket’s context quick to digest and preventing tasks from cycling indefinitely while they wait for a human decision.
The report does not announce a product launch, scheduled update or next milestone. For now, the next step described is continued refinement of the personal workflow, with Git holding the task record and the human retaining final responsibility for decisions and production deployment.
Key Questions
What does Kuhne mean by “AI brain fry”?
He uses the phrase for the mental strain of switching among many AI-assisted tasks, terminal conversations and follow-ups, until it becomes difficult to remember what needs attention.
How does the Git-backed queue work?
Tasks are stored as Markdown tickets in a project repository. An agent can work on tickets marked safe, while items requiring human judgment are collected in a prioritized owner inbox. Decisions are recorded on the tickets.
Does the agent deploy changes to production?
No. Kuhne says the agent never deploys to production. He keeps that responsibility, and says sensitive code changes are handled on a branch and require approval.
Does Kuhne say the system eliminates fatigue?
No. He says the work remains exhausting, though he feels less distracted and lost. The report offers a personal assessment, not measured evidence of reduced fatigue or increased productivity.
What parts of the workflow still need work?
Kuhne identifies making ticket context faster to understand and preventing blocked tickets from looping while they await a decision only he can make. He says he is continuing to improve the system.
Source: sergeykuhne.com
