Après-prompt: What Happens to Work When the Agent Keeps Going Without You

After Enter

There is a term called après‑ski. Literally, “after skiing.” It started as a simple idea: people would hang out after a day on the slopes. Over time, an entire culture grew around it — clothes, music, mountain bars, chalets, hot drinks, a visual language of its own. At some point, what happened after skiing became almost as important to the trip as the skiing itself.

Something similar seems to be happening with AI. You open Claude Code or Codex, describe the task, add the necessary context, press Enter, and the agent starts working on its own. It reads the repository, looks for the right files, changes the code, runs tests, hits an error, fixes it, and keeps going. Sometimes it realizes it took the wrong path, goes back, and rewrites what it already made.

Meanwhile, you are no longer typing. At first, that feels strange. You are clearly working, but you are not actually doing anything with your hands. Then you get used to it, and the gap between “do this” and “done” starts taking up more and more of your day. I call that gap Après‑prompt.

The Computer No Longer Needs Your Constant Attention

For the last few decades, working on a computer has followed roughly the same pattern: the person is almost constantly interacting with the interface. Writing text, moving objects around in Figma, switching tabs, editing CSS, going back to the IDE, typing again. Even good tools mostly made individual actions faster. They did not continue doing the work once you stopped interacting with them.

Agents change exactly that. More and more often, the person is no longer the one performing every individual step. Instead, they define the task, provide constraints, and decide whether the result is good enough. Previously, the time you spent working and the time you spent actively interacting with the computer were almost the same thing. Now they are starting to separate. The computer keeps working after you have taken your hands off the keyboard.

That feels like a much bigger shift than simply saying, “AI writes code faster.” The shape of work itself is changing.

Work Starts to Look Like Process Management

I increasingly notice myself working in a different mode. Instead of one task that I execute step by step, I have several processes running in parallel. One agent is looking at architecture, another is fixing the UI, a third is writing tests, and somewhere else a build is running.

You start the first task. While it is running, you formulate the second. Then you go back to the first, review the diff, send it back for another pass, switch to the third, and check what the second agent has done. It starts to feel a little like managing a small team, except the entire team lives on your laptop.

And that creates a new problem that barely existed before: what should the human do while the machine is working? The longer these autonomous chains become, the more important that question gets.

Waiting Becomes Part of the Interface

Traditional interfaces had a fairly simple goal: show the user the result as quickly as possible. You click a button, something happens. You drag an object, it moves immediately. You open a page, it loads.

AI interfaces are different. Some operations take a few seconds. Others take several minutes. An agent may perform dozens of actions before it needs the person again. At that point, waiting can no longer be treated as just a technical delay. It becomes a separate product state.

If Claude is working for 40 seconds, the question is no longer just how fast the model is. The question is what the user does during those 40 seconds. Do they watch the terminal? Read the log? Move on to another task? Get a notification when the agent finishes? Start another agent in parallel?

This is where some of the stranger experiments start to make sense: panels above the prompt, news while the agent is running, breathing animations, completion notifications, separate apps for monitoring multiple sessions. The individual implementation is less interesting than the underlying idea. For decades, software interfaces have tried to keep the user engaged. Now an interface can effectively say: you do not need to watch me right now.

The Desktop May Have to Change Too

If agents keep becoming more autonomous, the software will not be the only thing that changes. The structure of the workspace may change as well. The desktop is still built around the assumption that a person is actively working inside one application: a large window, a cursor, a keyboard, an active focus.

But what happens when five or ten agents are working at the same time? The main interface may start to look very different. Not an IDE filling the whole screen, but a process manager: what is running right now, what has finished, where a conflict appeared, which task is blocked, and where the agent needs my decision.

In other words, the “desktop” starts to become something closer to a control center. I think this is one reason why so many tools are appearing for managing multiple agents, terminals, and parallel sessions. We are trying to fit a new way of working into interfaces that were designed for a different world: one person, one application, one active task. That pattern is starting to break.

Speed of Execution Matters Less

If an agent can do in a few minutes what used to take an hour, then the speed of the person stops being the main constraint. It matters less how quickly you type, how fast you can assemble an interface by hand, or how much syntax you can remember.

Other skills become more important. How well can you define the task? What context should you provide? What constraints matter? How should a large problem be broken down? When can you trust the agent? When should you stop it? And, most importantly, how quickly can you recognize that a solution looks convincing but is actually wrong?

Part of the work is moving from execution to judgment. We spend less time directly producing the result and more time framing the problem, reviewing the output, and making decisions. That is why AI is not simply making the old process faster. It is changing what human work is made of.

Work Gets a Different Rhythm

Traditional computer work has a fairly steady rhythm: do something, get a result, do the next thing. With agents, the rhythm changes. First comes a short period of high concentration. You need to understand the problem, collect the context, and formulate the task properly. Then Enter. Then a pause. Then you come back, review the result, correct something, and launch the next run.

Sometimes several of these cycles are happening at once. Terminals are working on their own, a notification appears somewhere, another agent is waiting for approval. You might make coffee, walk around the room, or switch to something else, not because you got distracted from work, but because the work is continuing without your direct involvement.

This is where I think a new aesthetic starts to emerge. Terminals running by themselves, tiny status indicators, completion sounds, agent dashboards, a workspace designed around processes running in parallel rather than a person performing every action in sequence.

This Is Not Free Time

There is an important distinction here. Après‑prompt does not mean AI has suddenly given us a huge amount of free time. At least not yet.

The gap gets filled with other work almost immediately. You launch another agent, review the previous result, read documentation, think through the next task. If one task gets faster, people tend to find five more things to do.

So the more interesting question is not whether we will work less. It is what work will look like. It becomes less continuous, more parallel, and more dependent on assigning tasks and reviewing outputs. Less manual execution. More orchestration.

And This Is Not Just About Code

This shift is easiest to see in software development because coding agents are already fairly autonomous. But there is no reason to think it will stop there.

A designer could say: “Create three versions of this page using our design system, check them for accessibility, and compare them with the current version.” An analyst could say: “Review the last three months of data, find anomalies, and suggest five hypotheses.” A product manager could ask: “Analyze recent user feedback, group the problems, and map them to the current roadmap.”

In all of these cases, the person starts the work but does not perform every step themselves. That means Après‑prompt may not remain a quirk of software development. It could become a normal state of knowledge work.

Maybe the Interface of the Future Is a Queue

Today, AI is often added to existing products as a chat window. There is the familiar application, and next to it sits a text box where the user can type a request. But if agents really become autonomous, chat may not be the main interface at all.

A queue may matter more. Here are the tasks. Here is what is running. Here is what finished. Here is what needs a decision. Here is where the agent got stuck. Here is what changed since yesterday. Here is what can be started next.

Not conversation history, but working memory and the current state of ongoing processes. In that sense, today’s terminal agents may turn out to be something like the command line in early computing: an extremely powerful interface for specialists that eventually gives rise to an entirely different class of products.

Après‑prompt

I like the term not only because it sounds funny. It describes a genuinely new state quite well: the work has already started, the result is not ready yet, and for a while the human is not needed.

In the past, this kind of gap was treated as a technical problem. We called it loading time and tried to make it as short as possible. Now that gap is becoming part of the workflow itself.

And maybe an entire culture really will grow around it: its own apps, rituals, interfaces, workspace setups, and even its own aesthetic. A few years from now, it may feel slightly strange that people once sat in front of a screen for eight hours straight and performed every single action themselves.

For now, I like the name Après‑prompt.

The time between “do it” and “done.”