It Seems Better to Let AI Handle All AI-Driven Development

Lately, I have often felt that the flow of developing with AI has truly become familiar.

I have been doing software development for about ten years now, including my student years.

Of course, I have spent far more time in the era of writing code by hand, but over roughly the past six months, I think I have done almost no manual coding.

Instead, I give instructions to AI in natural language and spend my time trying to help the AI code better.

I imagine that many development teams in the web world have started to look like this.

I am strongly in favor of pushing development forward more and more with AI. Sometimes I even think that in a few more months, I may no longer be able to write code with my own hands. Even so, my support for this direction does not waver.

When people develop with AI, I think many of them start wondering where the boundary between humans and AI should be. For example, almost everyone has probably thought at least once about how far review should go.

Should you check down to the level of variable names, or only at the architectural level? Or should you do no review at all and rely only on black-box testing? Or should you let AI review the code and accept it if the AI says it is fine? I feel that deciding where to draw the line between human and AI responsibility and work is one of the most important challenges right now.

For reference, I will write a little about how I currently think about it.

When I first started coding together with AI, I checked things very strictly, down to the level of variable names. I designed the architecture myself, translated it into natural language, and delegated only the “actual implementation” to AI.

However, this approach is very inefficient. And AI performance has improved so dramatically that it is almost startling. Together with the progress in development environments built for using AI, this has led me to stop checking things at the variable-name level entirely.

I also feel that I have mostly stopped giving AI detailed opinions about implementation methods. Well, once the architecture is clearly decided, there may not be that much room for freedom anyway.

So how much review am I doing these days? Intuitively, it feels like I review code the same way I read natural language.

When I think about how I read Japanese text, I do not feel like I consciously process every single character. What I feel instead is that I am reading the “shape” of the writing. That is also how I review programs.

I do carefully read through complex functions, but in many systems, I think the overwhelming majority of code is fairly routine. Because of that, reading the “shape” of the program usually gives me a rough sense of what it is doing, and I end up judging things like, “It seems fine because it is doing this kind of processing here.” That is what my reviews have become like lately.

And once you move forward in this way, you begin to see only the outline of the codebase, while the details fade from view.

Back when I wrote programs by hand, I still had a kind of mental cache of the code I had written, so when I saw a bug, I sometimes had an immediate sense of where it might be. But when AI writes the code, I do not retain the details in my head at all. As a result, once I know there is a bug, it becomes harder to even guess roughly where it might be.

So in the end, I tell AI about the symptoms and have it fix the bug. And from experience so far, I have found that this approach is still very fast and highly accurate.

My conclusion is that there is no real choice but to keep pushing forward with this AI-driven development experience. It really is overwhelmingly faster than writing by hand, and more accurate as well. And I feel that the key to this style of development is to “do everything with AI.”