typing less, thinking more

I’ve noticed the cadence of my work shifting. Early days with coding agents were all about speed. Something that used to take hours was done in minutes, and sometimes I shipped faster than I could even think through the problem.

Lately, the rush feels less important. Chasing raw speed seems to distract from the real gain: having the space to explore ideas and dig into the solution space before locking anything in with code.

The slop tax

Looking back at those early months, most of my time went into cleaning up slop. I’d prompt out a feature, get 80% there in a flash, and then spend an hour fixing the brittle leftovers from the model. The code would run, but it never really fit. It was a classic case of attention being a budget¹ that I wasn’t tracking closely enough.

I was paying for speed upfront with extra debugging later on. It was faster, but it felt like my main job was just managing all the weird entropy that the machine introduced. Not really building, more like babysitting a turbocharged junior dev that couldn’t quite see the big picture.

Sparring with the model

Now that code comes almost instantly, the real bottleneck is just how clearly I understand the problem. Everything else is trivial.

These days, most of my work lives in a “sparring” phase with the LLM. No code gets written before we’ve argued it out: state management, boundaries, a couple of quick “spikes” (just to see if an idea has legs). It feels less like text generation, more like running a thought completion² loop, letting the model prod at the weak points in my ideas.

I’m no longer after pure implementation. I’m looking for a partner that can help me stress-test the architecture. Even the model’s simple magic of prediction is enough to surface cracks in my assumptions, before they show up as bugs.

Quality as the Baseline

Funny thing is, my total time to ship a feature is basically back where it started, pre-LLMs.

But what actually ships is larger scoped and sturdier with less creaks.

I used to spend those extra hours buffing the architecture, because building was just such a slog. The rush to deliver usually squeezed out the corners, the nuance. But now, because the typing is free, I can dedicate three hours making the system as robust as I want (at least, as much as I can), confident that writing the actual code will only take a few minutes once the design lands.

Implementation is so cheap that “spike first” is now my habitual approach. Every feature starts with two or three disposable spikes, just to push at the walls before anything goes live. It’s become planning as the new typing³.

Prototypes used to be the only way to get moving quickly. Now, I can spend time up front to build something truly scalable from the start, since exploring the options barely costs anything.

The balance has changed because I code way less, but think much more deeply. There’s room now to linger on abstractions, to design instead of simply transcribe. What ships ends up being a much clearer reflection of the thought that shaped it.

Footnotes

1. Attention is a budget — On the cognitive load of supervising LLMs. ↩

2. Thought completion engines — Shifting the focus from generating text to completing an architectural thought. ↩

3. Planning is the new typing — When implementation is free, the bottleneck shifts to design. ↩