The gap between building and understanding

I have been building personal projects with AI tools to learn, and I have noticed a pattern worth sharing.

AI can get me to a minimum viable product incredibly fast. Scaffolding that used to take days can now take a few hours. A blank folder becomes a working application before I have had time to fully think through every decision.

That speed is exciting. It is also where the trouble starts.

The comprehension gap

Understanding the code after it has been generated often takes longer than writing it would have taken on my own. The application works, but I do not always know why.

A few times, the gap became so wide that starting over felt easier than untangling what was already there. Technically, I was further ahead in the project. As a learner, I was further away from understanding it.

That is a strange kind of progress. The feature is finished, but the learning that was supposed to come from building it has been skipped.

Two kinds of speed

I have started thinking about this as two different metrics:

• Speed to MVP: How quickly can I get a working version in front of me?
• Speed to comprehension: How quickly can I explain the decisions, data flow, and tradeoffs in that version?

AI is very good at optimizing for the first metric. It can produce a plausible implementation almost immediately. The second metric is still my responsibility.

If I cannot explain a piece of generated code, I do not really own it. It lacks the feeling of accomplishment that comes from solving a problem and understanding the solution. I am renting the code until something breaks.

Using AI without giving up ownership

The answer is not to avoid AI. It is to change the way I use it.

I want to make smaller requests and accept smaller diffs. Instead of asking for an entire feature, I can ask for one step, read the result, and verify that I understand it before continuing. Reading and comprehending should happen before accepting, not after the project has become too complicated to follow.

Generated code should be treated as a first draft. It may be useful, but it is not automatically correct, necessary, or understandable. I still need to question the abstractions, remove what I do not need, and rewrite the parts that do not make sense to me.

This approach is slower at the beginning. It is usually faster when the project grows, because I am less likely to get stuck inside code I cannot explain.

What I am trying to practice

AI is an incredible tool for both building and learning. But for anyone using it to learn how to build, the discipline of slowing down matters more than the speed that got them there.

The goal is not just to have a working project. It is to become the kind of person who can maintain it, change it, and build the next one with a deeper understanding.

I still want the fast MVP. I just want comprehension to arrive with it.