Pomodoro vs Agent-Driven Breaks: Timing Movement to Claude Code and Codex Runs Instead of a Timer

The Pomodoro technique has survived forty years of productivity fads for a good reason: it works for work that is continuous. You set a timer, you push for twenty-five minutes, you stop for five, and the rhythm keeps you honest. Programming with an AI coding agent is not continuous. It is bursty: a minute of thinking and typing, then two to fifteen minutes in which Claude Code or Codex does the typing while you wait, then a decision, then another wait. A fixed timer cuts across that rhythm at random, and the result most people get is the worst of both: the timer goes off mid-thought, and the long agent waits are spent scrolling.

This post compares the two ways of scheduling movement breaks during a day of agent-assisted coding, timer-driven and agent-driven, as honestly as we can, including the cases where the timer is still the right tool. The agent-driven version here is NotchFit, which opens a guided exercise in the MacBook notch when Claude Code or Codex starts a task and tells you when the agent is done or needs permission; the timer-driven version is any Pomodoro app or a kitchen timer.

What Pomodoro gets right

Francesco Cirillo’s method, from the late 1980s, has three properties worth keeping. It is predictable: you always know when the next break is. It protects the work: the rule that a Pomodoro cannot be interrupted makes you defer the small distractions to the break. And it is external: the decision to stop is made by the timer, not by your willpower at minute forty, which is the moment willpower is weakest. Break-reminder apps that nag every thirty or sixty minutes are the same idea with a different interval, and we compared the main ones in NotchFit vs break-reminder apps.

If your day is writing, reading, design or hand-written code with no agent, keep the timer. Nothing below applies, and a 25/5 rhythm is as good a default as there is.

Where the timer breaks down with an agent

An agent-assisted session has two kinds of time that look identical on a clock and feel completely different in the chair. There is the time you are driving: reading the diff, deciding what to ask for, reviewing a plan, resolving a permission prompt. Interrupting that is expensive; it is the part where you hold the problem in your head. And there is the time the agent is driving: tests running, a refactor in progress, a subagent reading files. Interrupting that costs nothing, because you were not doing anything.

A timer cannot tell them apart. Set to twenty-five minutes, it will fire in the middle of a code review about as often as in the middle of a wait, and when it fires during a review you will dismiss it, which teaches you to dismiss it. Meanwhile the waits, which are the obvious time to stand up, go unused, because nothing marks them as breaks. The pattern is easy to recognise in your own day: plenty of idle minutes, and almost none of them become movement.

What agent-driven means in practice

Agent-driven scheduling flips the trigger. Instead of a clock, the cue is the agent starting work. NotchFit does this through a Claude Code plugin and Codex skills and hooks, installed with one click from its Setup screen: when a task starts, the notch expands into a panel with the next exercise from your plan animated on the left and the AI’s live progress on the right. The hooks run asynchronously, so they never slow the agent down, and everything talks to the app over localhost on your own Mac.

Three details make this more than a reminder with a different trigger. Every set starts only when you tap Start set, so an agent starting a two-second task does not drag you into a workout. If the agent finishes or needs permission while you are mid-set, the alert waits until the set ends, so you are never torn between a rep and a prompt (the reasoning is in why mid-set notifications wait). And the Hide workout toggle turns the notch into a pure status panel on days when you do not want to move at all, which is an honest admission that some days are like that.

Side by side

• Trigger. Timer: elapsed time, regardless of what you are doing. Agent-driven: the agent starting a task, which is by definition a moment you are not typing.
• Interruption cost. Timer: random; sometimes zero, sometimes a lost train of thought. Agent-driven: near zero, because the cue only arrives when the machine has the wheel.
• Break length. Timer: fixed, usually five minutes. Agent-driven: variable; a set is thirty to ninety seconds, and a long run can hold several sets with rest timers between them.
• Predictability. Timer: high. Agent-driven: low; on a day of short tasks you may get a dozen cues, on a day of thinking you may get two. This is the real trade-off.
• What you do in the break. Timer: whatever you like, which in practice is often the phone. Agent-driven: a specific exercise from a plan, with a countdown ring and Done, Skip and Pause, so the break has content.
• Knowing when to come back. Timer: you watch the clock. Agent-driven: the panel tells you when the agent is done or needs permission, with optional spoken alerts using on-device macOS voices.

The trade-offs, honestly

Agent-driven breaks have a floor problem. If you spend an afternoon designing, writing a document or hand-coding something delicate with the agent idle, there are no cues and therefore no movement. The research on short movement breaks, summarised in our exercise snacks post, points at frequency, not intensity; a day with zero breaks is the thing to avoid. The practical fix is a hybrid: let the agent drive on agent days, and keep a long-interval timer, sixty or ninety minutes, as a backstop that only fires when the notch has been quiet. You will rarely hear it on a busy agent day and you will be glad of it on a quiet one.

There is also a ceiling problem, the opposite case. On a day of many small tasks, every one opens the notch, and if you tried to do a set on each you would do nothing else. NotchFit’s answer is that sets never auto-start and skipping is a first-class button, but the discipline is still yours: treat the panel as an offer, do a set on the runs long enough to finish one, and skip the rest without guilt. Your plan, written by Claude Code with /notchfit:plan or by Codex with $notchfit-plan, sets days per week and minutes per day, and the streak and history heatmap show whether you are actually hitting them; a plan you keep skipping is a plan that asked for too much, and the fix is a smaller plan, not more willpower.

Finally, Pomodoro’s best feature, the protected focus block, has no equivalent here, and that is fine. The agent-driven model does not try to manage your focus; it only claims the minutes the agent already took from you. If you need help staying off Slack while you drive, that is a different tool, and the two coexist without conflict.

A simple way to run the hybrid

1. Install NotchFit, connect Claude Code and Codex from the Setup tab, and use the Try it simulate buttons to see the notch open once before trusting it on a real task.
2. Write a plan that asks for half of what you think you can do. On agent days the cues arrive on their own; your only job is to tap Start set on the long runs.
3. Keep a long-interval timer, sixty to ninety minutes, for the non-agent stretches. When it fires and the notch has been quiet, stand up and do the next exercise from the plan manually.
4. Review the heatmap weekly. If agent days are green and writing days are blank, lengthen nothing; shorten the timer instead.

NotchFit is a workout guide, not medical advice, and nothing here is a prescription; if a movement hurts, skip it. The point of comparing the two models is narrower than fitness: a timer schedules breaks against the clock, an agent-driven cue schedules them against the shape of the work, and when the work is bursty, the second one is simply aimed at the right minutes. It costs $20 once, runs on macOS 14 or later, and needs no account.