You Need to Be Able to Read What AI Wrote

You don't need to understand every line like its author, but you must see structure, data flow, dependencies, and where the gaps are.

The most nervous sentence in vibe coding is "what AI wrote, I can't understand." You really don't need to understand every line, but you must be able to read four things—otherwise you're delegating blind, which is no different from driving fast with your eyes closed.

After reading, you should be able to answer:

• To read AI output, what four layers at minimum?
• How do you tell "can't understand it" apart from "don't need to understand it"?
• Why does reading depth decide how much power you can delegate?

Four layers of reading

1. Structure How AI split the files, organized the modules, and where new things landed. You don't need to memorize it, but you should be able to spot "where it planted a bomb."

2. Data flow Where input comes from, where it's processed, and where the result lands. At least you can say "user clicks → what happens → where the result goes." If you can't, you haven't seen how its data flows.

3. Dependencies Which libraries it pulled in, which interfaces it used, how versions are set. One more dependency is one more risk; at minimum scan for new dependencies you don't recognize or that are heavyweight.

4. Gaps The boundaries that should be handled but aren't—no input validation, no error handling, no permission check. This is the layer that bites hardest, and where pure vibe turns over most often.

"Can't read it" vs "don't need to"

These are two different things:

• Don't need to: why a low-level hash is implemented as a lookup table, some library's internals. It doesn't affect your judgment
• Can't read it: you can't even say "what it changed and what it affects." That's the danger signal

The test: can I explain what it changed, what it affects, and where the risk is? If yes, not knowing the details is fine; if no, make AI walk you through it before you continue. copilot-cost

Reading depth = delegation size

• The deeper you read, the more you can safely delegate big jobs
• If you can only read the surface, delegate small, verifiable tasks
• If you can't read it at all, don't delegate—that's not vibe coding, that's betting

Read four layers, use the judgment standard, and understand the delegation boundary, and you move from "churning code" to "judging code." Wrap it up with a checklist you can run: review checklist.