The productivity paradox

More code is moving past me, way more than before. I'm genuinely glad, feeling a better programmer than before, as features that would have taken a week take a day or two. Small tools I'd have kept as sketches actually ship, so fast i don't even use them much as i go quickly to the next thing.

But we can't ignore the raw reality beneath the surface: this also means the amount of code moving past me is increasing faster than my cognitive ability to understand it.

I look at a file I "wrote" recently and I can't reconstruct why it's shaped the way it is, and that's not because i'm not trying hard enough. I'm not even sure what "trying hard enough" means in this context. It's not that i'm not paying attention, or that i'm not trying to understand.

A few weeks ago I hit a bug in a module I'd worked on with Claude Code across a handful of sessions. Not a dramatic bug. A quiet one, the kind that only surfaces under a specific sequence of inputs. I sat down to debug it and realized I couldn't read my way back to the decision. The code was correct enough that it had shipped. The logic was there. But the understanding of why that logic had taken that particular form hadn't come with it.

I'd been in the room for every session. I'd reviewed the diffs. Somewhere in the conversation, the understanding had stayed in the chat and the code had come out without it. I fixed the bug. I still don't fully understand that module, and I don't have the time to go back to it to learn it, now.

A different material

The obvious reaction to all this is: well, stay on top of it. Own the planning. Read the diffs. Keep the mental model. And that's right, but it's also not as obvious as it sounds, because we've never been in this situation before.

When I was leading a team of engineers, these things weren't practices I had to consciously defend. The pace enforced them. A person can only move so fast. A sprint is two weeks. A review takes the time it takes. The temporal consistency of a normal working week meant that I was automatically in the loop, because the loop ran at human speed. I didn't need a habit for staying oriented because the work couldn't outrun me.

What's happened now is that the pace has become something else entirely. It's like putting your head into a universe where time is a different material: something you can stop, compress, accelerate. A week of implementation in an afternoon. Three tools in a day that would have taken a quarter. And you're learning the commands for this, figuring out how to use them, and nobody handed you a manual because the manual doesn't exist yet.

So yes, the answer is to own the planning and stay in the mental model. But that's not a natural response to an environment you've always been in. It's a learned response to an environment that's new, and the learning is still happening.

Planning is the thing

After a while of paying attention to this, I've landed on one thing that seems to matter: whether I did the planning before handing off the implementation.

When I write out what a module should do, the shape it should take, where the tricky parts are, I can reconstruct the result even if the code is mostly generated. The decision is mine. The understanding comes with it. When I skip that and just start a session with a vague idea, the code that comes out is fine and the mental model stays in the chat.

It's not about coding more manually. It's specifically about planning: holding the decomposition, the structure, the why. That part I can't delegate and still feel like I was there. Everything else is negotiable.

I've started using a small check: before committing something Claude Code produced, I try to explain the change as if writing the commit message from scratch, not editing the one it suggested. When I can do it fluently, I was actually in the room. When I can't, that's the tell. The rate at which I can do it is lower than I'd like.

We don't know where this is going

There are tools in Paperworlds I would not have shipped without agents. Probably three or four of them. Without Claude Code, those stay as entries in a TODO.md and I return to the day job.

And I genuinely don't know where this is going. Not in a worried way, or not only in a worried way. There's something here that feels like the early days of learning an instrument: you're playing notes you didn't know you could reach, in combinations you didn't plan, and it's a little chaotic and a little beautiful and you're not sure yet if it's music. The planning habit, the reconstruction check, the deliberate slow-down before the commit — those might be the right responses, or they might be the first clumsy attempts at something that will look completely different in a year.

It's a problem and an opportunity at the same time. The lovely jazz you didn't know you could play.