Agents are slow

Before we start with agents, I must confess that I freak out when there is too much delay between me typing a key and a letter appearing in the editor. That's the kind of thing that distracts me, even if it's only milliseconds. I remember trying a lot of markdown editors a couple of years ago and rejecting them one by one because the character I typed was not there immediately. It was that distracting.

I also use a Vim plugin in my IDE because it allows me to make small changes very fast: appending text at the beginning or end of the line (I, A), removing multiple lines with a single command (d + 11 + ↓), or selecting and substituting a block of text. And then there's the killer feature: the dot shortcut (.), which repeats the last edit action.

Tab is the new dot

But to be honest, I use Vim's dot less often now. Cursor guesses your intent, suggests the location of the next change, and you just press tab. It moves the cursor there, you press tab a second time, and the change is applied. You don't need an internal monologue about which sequence of operations to repeat with a dot, and you don't need to navigate to that line. Everything just happens, immediately.

I wish I could have something similar with agent-assisted coding.

Typically, when you code by hand, you want to keep the time between change and validation short. Compilation should be real time, with hot reload in the running app. Tests should run fast. Programming is the art of minimizing feedback loops.

If you don't optimize it and you make a change, you need to wait a couple of minutes for test results. You get distracted. You're either idle, browsing social media, or starting another task. When the tests eventually finish, you need to recall the context, which takes time and effort. That effort accumulates and makes you tired.

The multi-agent context-switching hell

When an agent is doing a coding task, it usually takes a couple of minutes. Enough to get distracted. Worse, it feels easy to trigger another agent.

Agent thoughts displayed by Cursor or Claude feel like progress, but they’re just a spinner with better PR. You can stare at them, sure, but it seems like a waste of time.

You end up spinning another agent while waiting for the current one. First, you need to think about what you want to achieve and then type an informative prompt, maybe reformulating it a couple of times because the first version seems ambiguous. Then you press enter and check the status of the current sessions. Once you find the one that ended, you need to recall what the project was and what the agent was actually doing. Yet another context switch.

You have multiple tasks running in parallel and multiple contexts, and you switch over and over. It's draining. You feel overwhelmed, your context evaporates, and your performance collapses.

The ideal world?

Fast local feedback loops like hot reload, instant tests, and Cursor Tab provide superpowers while preserving deep work. In contrast, slow agent loops offer similar benefits, but at the cost of cognitive overload.

In an ideal world, I type my intent in a more convenient way than verbose natural language, maybe with some lightweight meta-language that strips out the fluff, maybe with a non-invasive brain-computer interface.

Then the result appears immediately. The app I'm working on is refreshed automatically and I can see a nice diff, such as the one presented by Cursor. Possibly I can even browse alternate versions and pick the one that fits best. Then I review, point out issues, and ask for improvements.

I can iterate fast in the same window, focusing on a single project and staying deeply focused on the task I want to achieve. That would be faster and less draining than managing multiple agents at the same time.

We are not there yet, but I believe we'll reach that point. Maybe fast agents will win over autonomous ones, and we'll regain flow state.