Reading AI-built code you didn't write

If you build through AI orchestration, you spend a lot of time reading code you did not type. This is a real skill, distinct from writing, and most people never develop it because they either trust the code blindly or regenerate it the moment it confuses them. Both are ways of avoiding the read. Learning to actually read AI-built code is what keeps a growing codebase from slowly drifting out of your control.

The mistake is trying to read it the way you would read a book, line by line, start to finish, holding every detail. That does not scale, and it is not how understanding works anyway. You read AI-built code the way you read a contract someone else drafted: you look for intent and invariants first, and you drop into the line-level detail only where it matters.

What are you actually looking for?

Three things, in order. First, intent: what is this code trying to do, at the level of the function or module? If you cannot state that in a sentence, nothing else you read will stick. Second, invariants: what does this code assume is always true, and what does it guarantee? Those are the load-bearing walls. A bug is very often an invariant that got violated, so knowing where they are tells you where to look. Third, the seams: where does this piece hand off to another, because interfaces are where AI-built systems drift, one side changing shape while the other still expects the old one.

You are not verifying every line is optimal. You are building a map accurate enough to navigate and to spot when something is off. When a model generates a two-hundred-line module, reading for intent and invariants might mean really focusing on twenty of those lines, the ones that carry the meaning, and skimming the rest with an eye for anything that contradicts the map. That is not laziness, it is triage applied to reading: spend your attention where the risk and the meaning are.

The reason this matters for a solo operator especially is that the codebase only grows. Every session adds more code you did not write. If you cannot read it efficiently, one of two things happens: you slow to a crawl trying to read everything, or you stop reading and let the drift accumulate until the system is a stranger to you. Reading for intent and invariants is the middle path that lets the codebase grow without leaving your understanding behind.

The takeaway: Read AI-built code for intent, invariants, and seams, not line by line. You're building a map good enough to navigate and to catch what's off, because the code you didn't write only piles up.