Most discussions about coding agents are about productivity: how much faster they make us, how much code they can write, and how much work we can delegate.

I've noticed a different effect.

Sometimes I give an agent a well-bounded task and realize I don't actually need to sit there watching it work. I can stand up, stretch, make coffee, or look away from the screen for a while. Occasionally I go for a short walk.

I've also noticed less neck discomfort this year. I haven't measured it, and I don't know whether the two are connected. But it made me curious enough to look into the research.

I think this points to a less obvious possibility of agentic software development: useful work can continue during moments when the developer no longer needs to be physically attached to the computer.

For a profession where it's easy to spend hours sitting still, that might matter more than it first appears.

Developer tools have spent decades trying to remove waiting. Faster builds, faster tests, hot reload, instant autocomplete. Coding agents introduce a strange new kind of waiting: you define a piece of work, hand it over, and the computer keeps going until there is something meaningful for you to evaluate.

That gap might be useful in ways that productivity measurements don't capture.

Software work keeps us at the screen

Programming can make it surprisingly difficult to move. There is usually one more thing to check: a failing test, a function to trace, a hypothesis that feels close to explaining the bug.

When I'm deep inside a problem, I'm carrying a temporary model of the system in my head. Getting up in the middle of it can feel less like taking a break and more like dropping the thread.

The tools themselves reinforce this. Type something and see the result. Change something and run the test. Save the file and watch the page update. The feedback loop gets tighter and tighter, which is great for development but can also give me fewer natural reasons to stop looking at the screen.

I've had plenty of days where I barely notice how long I've been sitting until my neck or shoulders remind me.

A timer telling me to stand up every thirty minutes doesn't really solve that tension for me. The timer has no idea whether I'm casually reading code or halfway through understanding something difficult.

A natural stopping point is different.

The hidden benefit is the handoff

Before handing a task to an agent, I've usually already had to understand the problem well enough to explain it, describe the constraints, and decide what a useful result should look like.

For example, I might ask an agent to make a bounded refactor, update the relevant tests, and run the suite. I still need to inspect the diff afterwards, check the assumptions, and decide whether the result belongs in the codebase. But I don't necessarily need to watch every intermediate step.

Autocomplete keeps me at the keyboard. Agents, when they can carry a task forward without constant input, create a different rhythm.

Instead of:

write → check → change → check

The loop can sometimes become:

understand → define → delegate → review

Between delegation and review, there can be a point where my next useful action is simply to wait. That gives me a place to physically disengage from the workstation without feeling that I've abandoned the task.

We've always had builds, deployments, database migrations, and CI pipelines that make us wait. But I usually experience those pauses as technical friction. With an agent carrying out a task, it feels easier to leave the work alone until there is something to evaluate.

Sometimes I stand up. Sometimes I make coffee. Sometimes I walk around for a few minutes.

The interesting part is that the software keeps moving while I move too.

What the research can tell us

The research I reviewed doesn't establish that coding agents make developers healthier. I didn't find direct evidence showing that developers using agents sit less, move more, experience less discomfort, or recover better during the workday.

But there is useful evidence around the edges of the idea.

The World Health Organization's guidance on physical activity and sedentary behaviour recommends limiting sedentary time and replacing some of it with physical activity, including light activity.

Research on short breaks is also relevant. A 2022 meta-analysis covering 22 study samples and 2,335 participants found small improvements in vigor and fatigue from micro-breaks, while finding no statistically significant overall improvement in task performance.

I actually like that result. Moving away from the screen doesn't have to make me more productive afterwards in order to be worthwhile.

Those findings don't answer the question I'm interested in, though. Short breaks aren't necessarily movement breaks. The participants weren't necessarily software developers. And none of this tells us whether coding agents change how much developers sit or move, or explains my neck discomfort.

The evidence supports encouraging less sedentary time. My suggestion is that coding agents may create new opportunities for it. That connection still needs testing.

The gap can disappear

Of course, there is an obvious alternative: start another agent, pick up another task, answer Slack, or review a pull request. Fill every available minute.

It's easy to imagine a future where agents make software work more intense rather than less. One delegated task might create a few quiet minutes. Five simultaneous agents might create a queue of things that all need reviewing, each carrying a different context.

Instead of moving away from the desk, the developer becomes the manager of a small fleet of machines.

Delegation doesn't remove responsibility either. Generated changes still require judgement: understanding what changed, checking whether assumptions were correct, thinking about architecture and maintainability, and deciding what should actually ship.

So agents don't automatically create healthier working habits. They create an opportunity. Whether that opportunity survives depends partly on how we use the tools and partly on the expectations around us.

If every productivity gain immediately becomes another unit of expected output, the gap disappears.

That raises a broader question:

Who gets the time that automation saves?

A small change I'd like to keep

What I can say more confidently than anything about my neck is that my working rhythm has changed.

Before using agents this way, taking a break during development usually meant deciding to interrupt myself. Now the work occasionally creates the boundary for me. I've understood the problem, handed over a bounded piece, and the next meaningful thing I need to do is review the result.

For a few minutes, there is no particular reason for me to keep staring at the screen.

What I'd like to see studied

I'd love to see this studied directly. What do developers actually do while coding agents work? Do they stay seated and watch, switch to another task, run several agents simultaneously, or stand up and move around?

Does total sitting time change? What happens to fatigue, discomfort, context switching, or perceived workload?

Much of the research on AI-assisted development that I encountered focuses on output: how quickly developers finish tasks, how much code gets written, and whether the code works. Those are important questions. But if agents are changing the structure of software work, output might not be the only thing worth measuring.

They may also be changing how continuously we need to sit in front of a computer. For software developers, that could be a surprisingly meaningful side effect of AI.

Not because the agent tells us to take a walk.

Simply because, every now and then, it gives us a reason to stand up.