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 handling multiple AI coding-agent tasks: track each task in Markdown files stored in Git, and collect decisions requiring human judgment in one inbox. The author says the approach helps reduce distraction and the feeling of losing track, while acknowledging that the process remains tiring and requires ongoing refinement.
A developer has described organizing work with Claude Code and Codex around a queue of Markdown tickets stored in Git, aiming to reduce the strain of switching among numerous AI-assisted coding tasks. In a personal report on sergeykuhne.com, the author says the system has helped them feel less distracted and lost, though they stress that the work remains exhausting and the tooling is still evolving.
The problem, the author writes, starts when an AI assistant is working on one task and the user starts another. Replies, follow-up questions and side tasks can spread across separate terminal tabs, leaving the developer to keep multiple task contexts in mind. The author calls this experience “AI brain fry” and identifies sequencing and context as the two main problems their experiment is meant to address.
In the described workflow, each task is a Markdown file in the code repository, and Git records the board’s state. An automated agent cycles through the board: it researches tickets, builds work a human has marked safe, runs tests and a browser check, and verifies work that is already deployed. For sensitive code, it uses a branch and asks for approval. The author says the agent does not deploy to production; that remains a human responsibility.
Items requiring a decision go into an “owner inbox,” which presents a prioritized list of reviews, questions and tradeoffs. A Claude artifact provides a single reading page, rebuilt from Git, with the board and a review page for each ticket. The author’s intended routine is to take one item, load its context, decide or request an action, then return the ticket to the queue. Git remains the record; the artifact is only a viewing surface.
A Workflow for Fewer Open Threads
The account addresses a practical challenge in AI-assisted software work: faster or parallel task handling can create more simultaneous threads for a person to monitor. When questions, reviews and follow-ups are scattered across terminals, the human may have to reconstruct what happened before making a decision. The proposed queue gives those tasks a persistent, shared record outside the chat session and groups requests for human judgment in one place.
The author’s report is a personal experience, not a controlled study. It does not establish that the method improves productivity for other developers or quantify its effects. Its relevance is that it offers a concrete process for keeping human decisions visible while delegating bounded work to coding agents. The distinction between agent work and human approval for sensitive changes and production deployment is also central to how the system is described.
The approach does not eliminate fatigue. The author says the work is still exhausting, but they feel less distracted and less likely to lose track of their purpose. That distinction matters: the claimed benefit is a better-organized workflow, not proof that AI coding tools reduce workload overall.
Products Worth Considering
Logitech MX Mechanical Wireless Illuminated Full-Size Keyboard, Clicky
Jackery HomePower 3600 Plus Portable Power Station, 3584Wh, 3600W
Samsung 49-Inch Odyssey OLED G9 (G91SD) Dual QHD Curved Gaming Monitor
As an affiliate, we earn on qualifying purchases.
Why Terminal Tasks Multiply
The source report focuses on developers using AI coding agents from the terminal, specifically Claude Code or Codex. It describes a pattern in which an assistant’s delay encourages the user to begin another task. When the first task returns with a question or follow-up, the work branches into more threads. The author says this creates a sequencing problem—what should happen first—and a context problem—how to remember the details of each task.
The author contrasts the queue with advice they say they have encountered, such as taking breaks, thinking before typing and limiting scope. Their experiment instead changes where task status and decisions are kept. Tickets live alongside the relevant code in Git, and the board can be restored from the repository if a session ends. A script turns outstanding decisions into a prioritized inbox, while each ticket’s review page collects information needed to assess that work.
According to the report, the process remains under active development. The author says they are still working on presenting ticket context in a digestible way and preventing tasks from entering loops when they are blocked on a decision only the author can make. The system is described as a living workflow, not a finished product or a widely validated method.
““I decided this way of working has two major problems: sequencing and context.””
— The author of the report on sergeykuhne.com
Limits of the Personal Experiment
The report does not provide measurements of time saved, error rates, output quality or changes in productivity. It also does not describe a comparison with another workflow, so the reported reduction in distraction is the author’s own assessment, not a measured result. No evidence is provided about how well the system works for other developers, teams or repositories.
Some implementation details remain unspecified, including how tickets are prioritized, what checks the agent runs in each project, and how the owner inbox handles competing or overdue decisions. The author also identifies unresolved issues: preparing useful context quickly and preventing work from stalling in loops while awaiting a human ruling. The report does not say whether these problems have been solved or whether the workflow has been tested beyond the author’s own use.
The Queue Remains Under Revision
The author says they plan to keep improving the system, particularly how it supplies ticket context and handles tasks blocked on human decisions. The report describes no scheduled release, product launch or external evaluation. For now, the next step is continued iteration on the author’s own workflow, with production deployment and decisions requiring judgment remaining with the human operator.
Any broader conclusion will depend on evidence beyond this account. Further reporting or testing could establish whether the approach reduces task-switching costs for other users, how reliably agents complete work under its rules, and whether the review queue prevents missed decisions without creating new administrative work.
Key Questions
What does the author mean by “AI brain fry”?
The author uses the phrase for the exhaustion and loss of focus they associate with juggling multiple AI coding tasks, follow-ups and terminal tabs at once.
How does the proposed workflow work?
Tasks are stored as Markdown tickets in Git. An agent works on tasks marked safe, while items needing human review or a decision appear in a prioritized owner inbox.
Can the agent deploy changes to production?
According to the author, no. The agent may build and check work, but the author keeps production deployment under human control. Sensitive changes are built on a branch and require approval.
Has the approach been shown to improve productivity?
The report gives no measured productivity results or independent evaluation. The author says they feel less distracted and lost, while also saying the work remains exhausting.
What problems does the author still need to solve?
The author says it remains difficult to present ticket context quickly and to stop tasks from looping when they are waiting for a decision only the author can make.
Source: sergeykuhne.com
