There seem to be two camps of thought when it comes to AI for coding. One camp says, no matter what type of AI you use—autocomplete, chat, or agents—you must check every single line of code that it writes. We can call this the methodical coding camp. And the other camp is more of the vibe coding camp, where they say, just let AI manage your codebase, it’s going to be fine.

My belief that I’ve developed over the past two years of using AI for coding is that neither camp is actually correct. The correct way to think about this is to say: for the given task that I’m working on, what’s the right level of complexity that I need to choose? Do I need to check every single line of code because it has severe security implications? Or maybe you want it to be maintainable and you want to be careful about every single line of code you commit? Or do you say, for this particular project, it’s not that important for every single line of code to be checked so carefully?

Maybe you’re working on a one-off project that you just need to use for a day or two. Or maybe you’re working on a medium-sized project where you don’t necessarily have to check every single line of code, but you still want the codebase to be structured nicely. In that case, you want to be careful about where files are, what technical choices you make at the beginning. And if you want to be a bit more careful, then you might want to write some tests. You might want to start to create some CI guardrails to increase the quality of your codebase as well.

So really, the question is, it’s not a matter of being in one camp or the other. If you’re so dogmatic about your belief about which one is correct, you’re probably wrong. Because as I said, in my opinion, the correct position is to be a bit more flexible and choose the right level of complexity, depending on the context.

Sometimes, in some situations, writing every single line of code, every character of the code by hand is the right choice. If the AI that you’re using doesn’t have a lot of training data on the particular language that you’re using, for example, then you might need to write everything by hand. That’s totally fine. But on the other hand, if you’re working with a large codebase and you just need to understand specific parts of the codebase, not necessarily everything, then you can just ask an AI agent to go through the codebase, traverse through it, so that you can find the exact thing that you’re looking for. You can just ask high-level questions about it first and then go down in the hierarchy of complexity.

The complexity gradient

[Chart placeholder: A gradient showing 100% vibe coding at the top (highest complexity) to 100% manual coding at the bottom (lowest complexity)]

We’re looking at this gradient that goes from 100% vibe coding to 100% manual coding. As you can see, 100% vibe coding is shown at the top because it is at the highest level of complexity where you forget that code even exists. And at the bottom, you have 100% manual coding, the lowest level of complexity. This is a gradient, and you can flexibly choose where you want to be on this chart.

• 100% vibe coding: You don’t care that much about the quality
• Below vibe coding: You start to care about the architectural decisions
• A little below that: You start to care about general structure of the codebase
• Further down: You start to care about guardrails, testing, CI
• PR reviews: Would be somewhere in this gradient
• 100% manual coding: Every character matters

In practice

So in practice, what would that look like? Well, if you’re using an AI agent like Claude Code or AMP:

For a one-off project: You might just ask the AI to create the project for you, not think about the codebase at all, just forget that the code exists, vibe code all the way, and you’re done.

For a medium-sized project that you want to use for yourself and want to be somewhat maintainable: You might not care that much about every single line of code that you write, but you probably care about the general structure of the codebase.

For a professional enterprise codebase: You can still use AI agents, especially for understanding the codebase, but before you send that PR, you might go ahead and check every single line. But if you feel like it’s too much to check every single line of code manually, then you might ask AI to use the github-cli command to pull information from your own PR, or maybe use git-cli itself to check the diff between the current branch and main to understand what the difference is exactly. Then you can ask, “Can you walk me through at a high level what each file does exactly?” So you can just ask high-level questions that way, and if you’re still confused about certain files or certain parts of certain files, then you can dig into those, ask those questions. You can basically start from the highest level of complexity and then go up and down depending on what you need to know and what you need to understand.

The Harry Potter analogy

I guess perhaps a good analogy is, let’s say you’re trying to read Harry Potter. At the lowest level, if you want to read everything carefully, then what you can do is obviously read everything word for word. If you want to just understand the general plot, if you’re using AI to understand Harry Potter, you might say, “Okay, summarize chapter one for me, chapter two for me, chapter three for me,” and you can go from there. But you might be curious about the summary that AI gave you on chapter three, so you can dig into it, and if you want to ask very specific questions, you might need to dig into a specific sentence, even a specific phrase, specific word, to understand exactly what the story is trying to tell you.

This is pretty much exactly the same thing with vibe coding, agentic coding as well. Sometimes it’s okay to stay at the chapter level. Sometimes it’s okay to even stay at the book level if you have an advanced enough AI. But sometimes you need to go down to the word level, sentence level—it all depends.