Over the past year, AI tools for software development have improved dramatically. They can increase both velocity and, in many cases, the quality of the output. Pretending otherwise isn’t realistic. Teams that learn how to use these tools well clearly gain an advantage.

But there’s another dimension that deserves more attention alongside speed and output quality: depth of understanding of the systems we build.

One concern I have is the potential erosion of in-depth knowledge of the codebase. As more code is generated or reviewed with AI assistance, developers may interact with the code more superficially. You might understand what the code does without fully understanding why it exists or how it fits into the broader system.

That deeper understanding is what allows engineers to debug complex production issues or make good architectural decisions. And it’s difficult to rebuild once it’s lost.

I’ve also seen the flip side of the “AI increases velocity” argument in practice: very large pull requests that clearly leaned heavily on AI generation. The code isn’t necessarily wrong, but it often introduces a lot of unnecessary or overly verbose changes. Humans still need to read, review, and maintain that code later.

In those cases, the speed of generation doesn’t translate into the speed of comprehension.

So for me, the real framing isn’t “AI vs. human craftsmanship.” It’s intentional use of AI.

AI is an incredibly powerful tool. But it’s still a tool. The real skill might be knowing when to use it and when not to.

Used thoughtfully, AI can absolutely raise the bar. But that still requires engineers to stay deeply engaged with the systems they build. Otherwise, we risk trading short-term velocity for long-term understanding.

In other words: I’m very pro-AI, but I’m even more pro intentional engineering.