People ask me all the time if I've gotten faster since I started taking this seriously. Not really. Not yet, at least. That's usually not the answer they're expecting, and I get it, it's not exactly the story you'd think you'd hear from someone who spends most of his day directing agents instead of writing code himself. But it's the honest one, and I think it's more interesting than the version people want to hear.
Here's how it actually went, step by step. Not because I planned it that way. Just because each step made the next one obvious.
It started simple. It can code for me, so let it code for me. Then it was, why stop at one agent, why not have a few running at once. Then, why am I still the one kicking each one off, can this just run on its own. Then it wasn't a task anymore, it was a workflow. Then the workflow became a loop, because I got tired of telling it the same things every single time. At some point the agents started telling each other what to do next, without me sitting in the middle of it. And somewhere in there I built skills, so I'd stop re-explaining the same context over and over. The tool would just already know.
And then I became the bottleneck.
Not because the code stopped coming. It kept coming, faster than before, actually. The bottleneck was me. Everything piled up at review, because someone still has to check the work, and that someone was me, every time, for everything.
That's the part nobody really warns you about. Speed on the output side just moves the pressure somewhere else. If the only thing you've built is a faster way to produce code, you've built a faster way to produce a review backlog. I would say that's the trap. It looks like progress right up until you're the one drowning in it.
So that's where the real work started. Not the automation part, the trust part. Hooks that catch things before they land. Skills built specifically to verify, not to produce. Loops whose whole job is to check whether the last loop actually did what it claimed. Gates that ask, before anything counts as finished, whether the things that got touched were actually the things that were supposed to get touched.
Because "done" isn't the bar. Safe is the bar. Done just means it stopped. Safe means I can trust it without going back and checking everything myself, which, if you think about it, is the entire point of delegating something in the first place. An agent that finishes fast but leaves me re-checking all of it hasn't saved me anything. It's just moved the work to a different part of my day and made it feel more urgent.
So no, I'm not faster yet. But here's where I think the time actually goes, and it's the part I don't talk about enough.
Every hour these tools buy back doesn't turn into an hour of doing more of the same thing faster. It turns into an hour of getting better at the thing itself. Some of that is building, the hooks, the verification loops, the skills I just mentioned. But a good chunk of it is just learning. Tutorials. Docs. Reading up on what changed this week, because something always changed this week. Trying a setup just to see if it breaks. Watching someone else's approach and stealing the one idea in it that's actually good. None of that shows up as output today. It shows up as a better foundation for tomorrow.
That's the loop, if I'm honest about it. Buy time, reinvest the time into getting better, which buys more time next round, which gets reinvested again. Output was never the metric I was optimizing for. Depth was. Still is.
I think that's actually the whole answer to "are you faster now." Not really, because I keep spending the gains on going deeper instead of banking them. It has made me a bit faster too, just not as much as you'd expect from someone doing this all day. That's a trade I keep making on purpose, speed for depth, and I don't think everyone needs to make the same one. Plenty of people get real value out of this without going anywhere near this deep, using it as a sharper autocomplete and leaving it there, and that's a perfectly good place to stop if that's what you actually need.
I guess at some point my trade flips too, and the depth turns into speed on its own, without me having to think about it. But I'm not in a hurry to get there. The thing I keep coming back to is that this isn't a shortcut you learn once and cash in forever. It's more like a way of thinking that keeps asking itself the same question on repeat. Faster, sure, but also safer. More autonomous, but also more trustworthy. And because of that, eventually, actually faster. For real this time, not just on paper.
I don't have a tidy lesson to wrap this up with. Just something I noticed about my own work that felt worth writing down. Maybe it's useful to you too.