Background

The traditional Pomodoro Technique asks us to spend twenty-five minutes on one thing without interruption or context switching. That premise clashes with how we now work through Agents such as Claude and Codex. An Agent may take one minute, ten minutes, or even half an hour to respond, while the human decision or input often takes less than a minute. The rest seems to be nothing but waiting.

Based on a rough estimate of my own experience, actual human input may account for less than 10% of an Agent task cycle, and active work for less than 30%. The rest is spent waiting for the Agent to return. These are not rigorous statistics. They merely describe a very specific feeling: I am sitting in front of the computer, yet I cannot stay genuinely engaged with one thing for twenty-five consecutive minutes.

To avoid “wasting” that waiting time, some people open three or four conversations and run several tasks at once. Others watch anime, scroll through short videos, or read fiction while they wait.

Neither response works particularly well.

Keeping several conversations open leaves us in a constant state of interruption and context switching. Just as a complex problem begins to take shape in our mind, another conversation finishes and pulls our attention away. Work like this for long enough, and it feels like being downgraded from Claude Opus 5 to Sonnet 5. The tool has not become less capable; our own thinking has been fragmented.

Filling every pause with entertainment looks like harmless slacking, but it can also remove our sense of participation in the work. In the end, we are left with a result that barely feels like ours and little else. Over time, that brings us back to the question in In the LLM Era, What Exactly Is My Ability?.

This may also explain part of the knowledge anxiety people experience in the Agent era. One group decides there is no point learning because AI learns faster. Another appears to be learning and advancing many things every day, yet grows even more anxious because they never think any one thing through from beginning to end.

The Real Conflict Is Not Waiting, but Continuous Monitoring

An Agent running in the background does not necessarily break our focus. What breaks it is not knowing when the Agent will finish or whether it will stop and wait for one more “please continue.” We leave part of our attention behind in the conversation window.

A new request often goes through the same sequence:

1
Describe request -> Make plan -> Implement -> Verify and test -> Open PR -> Human review -> Refine -> loop...

Beyond the initial description, key decisions, and final review, many intermediate steps in small tasks do not require continuous human involvement. Yet in a conversation-driven Agent session, the work may stop whenever the human is not there to confirm the next step.

Instead of making high-value judgments, the human ends up polling:

• Has this conversation finished?
• How far has the plan progressed?
• Did the tests run?
• Is it ready for a PR?
• Should I check the other conversation too?

That is the main source of boredom: repetitive prompts that push the work forward, followed by repetitive waiting.

Conversation is well suited to clarifying an ambiguous problem, but poorly suited to serving as the long-term unit of project management. A feature may be discussed in one conversation, implemented in another, and debugged in a third. The number of conversations grows while the context belonging to the same task disappears into the noise.

Prompting an Agent to “skip the plan, finish everything, and open a PR” does not solve this. Plans are useful. The problem is that the plan, progress, and result are all trapped inside one conversation. Without stable task state, we cannot see where the work actually stands, so we keep returning to completed conversations to check.

From Conversation-Driven to Task-Driven

The compromise is neither unlimited Agent autonomy nor the complete removal of conversation. It is to change the basic unit of work management from a “conversation” to a “task.”

A task might move through these states:

1
Backlog (idea) -> To Do -> In Progress -> In Review -> Done

I prefer to group them into three broader stages.

A Reference Implementation Already Exists

The video “Stop Managing Codex Through Conversations” demonstrates dashi-taskboard, which is close to the model described here. It organizes work into Backlog, To Do, In Progress, and In Review; Codex claims tasks from the pool, while context is indexed by feature across conversations.

The project is open source on GitHub: chuspeeism/dashi-taskboard. It is not the only possible answer, but it shows that a task board is more than an abstract idea—it is already a workable interaction model.

The latter half of the video raises another easily overlooked issue. An automated workflow cannot remain sustainable if every step depends on a human returning to feed it another prompt. At the same time, a workflow without a human present needs a safe fallback. To me, that fallback is not permission for the Agent to decide everything on its own. It is the ability for tasks to pause, queue, and wait for review. When nobody is watching, it is better to stop in review than to quietly bypass human judgment.

Why Is This Compatible with the Pomodoro Technique?

The key is to redefine what it means to “do only one thing during a Pomodoro.”

That one thing should be the cognitive task currently owned by the human, not “watch an Agent process until it finishes.” For example:

• Use one Pomodoro to clarify a goal, split the task, and write acceptance criteria.
• Use one Pomodoro to solve a design problem that genuinely requires your reasoning.
• Use one Pomodoro to review a high-risk change in depth.
• Group several tiny, low-risk results into one Pomodoro for batch review.

After handing a task to an Agent, stop continuously monitoring the conversation. A completion notification is simply a new event: it enters the review queue and waits until the current Pomodoro ends or the next scheduled review period begins. Several Agents may be running in the background, but the human mind still has only one foreground goal.

This is different from keeping four conversations open and switching whenever one of them makes a sound. In the first model, machine execution is parallel while human attention remains single-threaded. In the second, human contexts are treated as parallel, leaving nothing but fragments.

If the current human task is complete while the Agent is still running, there is no need to invent another complex problem merely to fill the remaining twenty-five minutes. Use the time to review the work just completed, record the next step, or simply rest. The Pomodoro serves attention, not attendance.

A Compromise, Not a Replacement

Conversation-driven work still has value. Ideation needs conversation to clarify a problem, and review needs conversation to explain trade-offs and correct deviations. The middle—the work whose goal is already clear, whose steps can proceed continuously, and whose result can be verified—is what belongs in a task system.

What I want is not to “never talk to an Agent again,” but this:

Use conversations to think and tasks to advance; let Agents execute asynchronously while humans focus synchronously.

The Pomodoro Technique protects human attention. Task-driven work handles Agent waiting and progression. Their point of compromise is that humans no longer accompany every run from beginning to end, and we do not mistake the machine’s capacity for parallelism for our own.

When progress and results accumulate around tasks, people can finally leave behind repetitive phrases such as “please continue,” “how far did you get?” and “run the tests.” Our limited attention can return to the parts truly worth thinking about, judging, and learning from.