the prompt gap

There is a peculiar new form of distraction emerging from the age of coding agents. It does not happen when a developer is stuck on a complex problem, or when claude code builds something you didn’t even ask for. It happens when everything is going remarkably well. An AI coding agent has been given a task, the terminal is filling with activity, files are being opened and rewritten, tests are running somewhere in the background, and for the first time in years an agent appears to be doing the challenging part of programming. There is nothing left to do except wait. So the hand reaches for the phone.

This is where the modern AI workflow has acquired an amusing contradiction. The machines have become remarkably good at occupying themselves, while the humans have become remarkably bad at doing the same.

The few seconds between prompts have traditionally been treated as dead time. With an AI agent, they are anything but. The agent may be writing code, but the human is often doing something more important: deciding what comes next. The previous response is being evaluated, the architecture is being reconsidered, an edge case is being remembered, and the next instruction is being formed somewhere in the background. The apparent pause is actually part of the work.

That distinction becomes important as AI coding moves away from autocomplete and toward genuinely agentic programming. Modern coding agents can inspect repositories, modify multiple files, run tests, use external tools and iterate on their own work. Recent research into agentic programming describes the process as a multi-step loop rather than the old model of giving a model a prompt and receiving a piece of code in return. Other recent work has gone further, arguing that the central problem in agentic software development is increasingly one of context management: what the agent knows, what the human remembers, what decisions have already been made, and how all of that survives across a long sequence of interactions.

The implication is easy to miss. Prompting is no longer quite like asking a search engine a question. It is closer to playing chess.

Agentic programming has started to look remarkably similar. A prompt might ask an agent to refactor an authentication system, but the real thought process may already include what should happen if the tests fail, whether the database layer will need to change, whether the API contract should remain untouched, and what the next two or three prompts should be if the agent discovers something unexpected. The prompt is only the move. The strategy exists in the gap around it.

That makes the phone sitting beside the keyboard a surprisingly effective opponent.

The modern smartphone does not need to convince anyone to abandon a work session permanently. It only needs to capture a few seconds at the right moment. A notification becomes a message, a message becomes a social feed, a social feed becomes a video, and a video becomes another video. The entire sequence can take less than a minute while still being long enough to replace the mental state that existed immediately beforehand.

This is the part of the doomscrolling conversation that tends to get lost. The problem is not simply that scrolling consumes time. Time is relatively easy to measure and therefore relatively easy to moralize about. The more interesting cost is context. Every interruption creates a small tax on reconstructing what was happening before the interruption occurred.

Research into problematic social-media use and doomscrolling continues to associate compulsive consumption with distraction, difficulty regulating attention and reduced productivity. At the same time, the software industry is becoming increasingly interested in the opposite problem: how to preserve context across long-running AI workflows. Anthropic has described context as a critical and finite resource for AI agents, while recent research on coding-agent workflows argues that errors introduced early in research and planning can compound later in the development process.

There is an almost comic symmetry here. The AI is being taught to maintain context while the human is being trained to abandon it.

The irony becomes even stronger when the AI itself is responsible for the pause. A developer gives an agent a substantial task and waits for it to finish. The machine may spend two minutes reading the repository, three minutes changing files, another minute running tests and another minute trying to understand why one test failed. During those minutes, the human has a choice. The terminal can remain open, and the mind can remain on the problem, or the phone can provide an endless stream of unrelated problems that require absolutely no effort to solve.

The second option is extraordinarily attractive because it feels harmless.

There is no obvious interruption. No meeting has been scheduled. No colleague has appeared at the desk. No urgent email has arrived. There is simply a small gap in which nothing appears to be happening.

Except something is happening.

The next prompt is being formed.

That next prompt is often where the quality of the entire interaction is determined. A poorly remembered prompt produces a shallow correction. A distracted developer asks the agent to undo something that was intentionally changed. A forgotten constraint disappears. An architectural concern that seemed obvious ten minutes earlier has to be rediscovered. The model remains perfectly capable of answering the question; the problem is that the question has become worse.

This may become one of the stranger productivity problems of the AI era. As models become more capable, the bottleneck increasingly moves away from generating code and toward directing the system that generates it. Recent research on agentic software development is already pointing toward this shift, with studies emphasizing planning, verification, context management and human oversight rather than simply measuring how many lines of code an AI can produce. One recent synthesis described the emerging problem as a shift from asking how much code an agent can generate to asking how much reliable, production-qualified work the overall human-agent system can actually deliver.

In other words, the scarce resource may not be intelligence anymore. It may be continuity.

This is why the increasingly popular language around “vibe coding” can be slightly misleading. The appealing fantasy is that programming becomes effortless: describe an idea, let the machine build it, watch the application appear. But serious agentic development is becoming something more interesting than passive delegation. It involves steering. There is a constant exchange between intention and execution, between what the human knows and what the agent discovers. The developer becomes less of a typist and more of an orchestrator.

That orchestration requires a surprisingly old-fashioned skill: staying with an idea.

The technology industry has spent years trying to eliminate friction from computing. Faster processors eliminated waiting for programs to load. Faster networks eliminated waiting for pages to appear. Better interfaces eliminated unnecessary clicks. AI is now eliminating much of the waiting involved in writing software. Yet the removal of one kind of friction has exposed another. When the computer no longer requires constant attention, the human has to decide what to do with the attention that has been returned.

The obvious answer, unfortunately, is the phone.

This is where doomscrolling becomes more than a lifestyle complaint. It becomes an architectural problem in the modern knowledge-work stack. The laptop contains the project. The AI agent contains the execution capability. The phone contains an industrial-scale machine for destroying whatever concentration remains between the two.

There is a reason the comparison to chess feels increasingly appropriate. Chess requires holding a position in the mind. Agentic programming does too. A good interaction with an AI coding agent is rarely a collection of isolated prompts. It is a conversation in which every answer changes the meaning of the next question. The agent proposes something, the human evaluates it, the agent receives another instruction, the resulting change reveals a new problem, and the process continues. The quality of the final result depends partly on whether the human can preserve the thread long enough to make good decisions several moves ahead.

The prompt, in that sense, is only the visible tip of the work.

The invisible part is the gap.

And the gap is becoming increasingly valuable.

Perhaps this explains a strange phenomenon appearing among people who spend their days working with AI agents: the desire to protect the periods when the agent is busy. The terminal running in the background is not an invitation to browse. It is an opportunity to think. The machine is finally doing the execution work quickly enough that the human can step back and reason about the larger system.

The worst possible use of that moment may be to fill it with something specifically designed to prevent sustained thought.

Popular apps like Opal allow the user to block off distractions at scheduled intervals and more niche tools like cantscroll specifically block distractions during coding sessions, allowing the human to stay in tango with the coding agent. The idea is deliberately smaller than the usual productivity sermon. There is no need to delete every social app, disappear into the woods or pretend that a twenty-minute break on TikTok is a moral failure. The point is simply that not every pause is a break, and not every gap should be filled.

Sometimes the agent is running a test suite. Sometimes the model is thinking. Sometimes the next prompt is already taking shape. And sometimes the most productive thing that can happen between two prompts is nothing at all. Because the future of programming may not be about writing faster.

It may be about thinking farther ahead without losing the position.

That is the prompt gap.