This really got my attention. I use Claude heavily and although I am sure it is saving me considerable time, I feel like my "delivery" speed is roughly the same. I think the realization that will come from this is that writing code is not that consuming after all; unless you are doing cryptography or math.
Most of your time is spent testing, deploying, figuring out some weird bug, writing docs somewhere, signing up to some service, etc...
While writing code I think about what I am doing, improvements, etc. To write easy boilerplate code helps me to find improvements or even realize that there is some risk I overlooked. It is a zen state that helps with the deep thinking part.
Not writing code forces me to read and reread the code to get the same realization. That is why it is harder to work with code written by other people.
In the age of AI all code is code written by someone else that I have to maintain, it looks like a nightmare.
Yeah I have the same. In general, writing (and experimenting) is how I _think_. If I read code, it takes me a lot longer to understand.
Sure, I save some time by not having to do any trial and error, I'm looking at a solution that already works according to some testing. But then I start to wonder about edge cases, leaky abstractions and such, and not having done the work, that's where a lot of the effort saved by not writing it comes back, at a stage where the work is seemingly already done and "just" needs reviewing, which is somehow more frustrating.
Perhaps people are just different. I work great on a blank canvas. I know a lot of people struggle immensely with it. Hell, some people type so slow or have such low mastery of their tools, I really feel their pain watching them.
One old trick that helps a bit with understanding, is to not copy paste what the AI suggested, but rather to manually copy the code suggested the way you would do it with a physical book.
Ive done some vibe coding with working but code wise horribly results. But I have had working prototypes faster than ever.
But I recently starting doing some redesign and architecture changes (manually) in an old code base and notice that i tab trough whole files auto fixing code one by one with suggestions which is amazing.
I think we need to find a way to work with it and keep it far away from making architectural decisions for now.
I became hyper attentive to iteration speeds as a result. This is not just something a human runs into, the agent runs into it even more because it loves to run tests etc. The quicker that goes, the more efficient the agent is. Obviously the same should be true for humans but because the agent doesn't make breaks quite like a human does, it becomes more noticeable.
It gets me frustrated. Here you are one second flying, in the zone, moving from concept to concept at faster than human speeds; and then boof, you have to pull up some random api doc, open postman, test the api, come back to the chat console, etc...
Overly verbose codebases are not great for agents in my experience because they confuse them greatly and make refactoring hard. However codebases that I find to work really well with agents are quite lite on abstractions and I always felt that this is the right way to build software for humans too.
I have a lot of functions, I pass a lot of data, I embrace a lot of thread local state and this works really well for both humans and AI to understand what is going on.
But here is where agents and humans both agree: quick and easy tooling. Make it easy to iterate on a test, make it easy to manage resources, make the iteration cycle as quick as possible. I'm writing this as my partner's job forces iteration cycles of minutes on her. No agent can do better in that space than a human.
This really got my attention. I use Claude heavily and although I am sure it is saving me considerable time, I feel like my "delivery" speed is roughly the same. I think the realization that will come from this is that writing code is not that consuming after all; unless you are doing cryptography or math.
Most of your time is spent testing, deploying, figuring out some weird bug, writing docs somewhere, signing up to some service, etc...