Raging against the machine

I’ve never been one to get angry while working. People often refer to me as the calm voice in the room. In my professional life, I never see anything worth getting mad about.

That is until I started coding with AI.

Agentic coding can be wildly infuriating. I wrote the other day about how it forced us to build systems of trust that teams often ignore. That’s a positive aspect of vibe coding but it’s not all joy.

Usually everything is fine. You write what you want. You make a plan. You set it on it’s task. You test and review. Do a few iterations. And great, it saved you a lot of time and typing.

But then sometimes everything is not fine. You tell it what you want. Make that plan. Set it going and come back to something different than what you asked for. Or broken. And no amount of iteration seems to fix it.

Then the rage sets in.

Unlike manual coding, agentic coding is unpredictable. If you ran the same request many times you would get different results. Your descriptions of what to change are lossy and it’s easy to overstretch a request. One false assumption can send it off down the wrong path.

While agents seem to understand you, they really don’t. Not the way a person does.

Of course, the models behind these agents have some type of understanding of language.

But the agents are running these models many times during a task. They maintain a written summary as a model of understanding. If anything goes wrong in that summary, things go off course. And it’s not easy to introspect.

Recently this happened with a UI I was building. I asked the agent to draw in ASCII what it thought I was asking for and it was completely accurate. Yet turn after turn it could not build the thing.

I reset from the start, asked again, and got it immediately.

When this kind of thing happens the system can stop feeling like it’s saving you time. Instead, it feels like it’s wasting your time.

There recently was a leak of Claude Code. It turns out they track frustration based on words and phrases. So, telling the agent to go fuck itself can let the developers know it’s doing something wrong.

Planning stages help build a shared agreement with the agent before it does anything. But it’s not foolproof. My recent experience was after plan iteration.

This will get better with time. A year or so ago, the need to handhold it was the norm. Now, it’s much more random. So, when it happens, it’s more surprising. We may get to a point where it’s so rare that it’s a non-issue.

I expect IDEs will need to transform to adapt to agentic development. Outcomes need to feel more predictable and developers need to feel more control.

Until that happens, we’ll continue to rage.