The first review is from the agent itself.

“Left alone, I generate the most statistically plausible code for your request. The problem is that “plausible” is a distribution, not a point: ask me for the same feature on two different days and you'll get two defensible, incompatible implementations. Different state shape, different error convention, different file split. Each one passes review on its own. Together they're drift.”

“With the catalog loaded, the canonical shape for your stack is in front of me before I write — multi-tenant isolation, status enums instead of booleans, where the types live, how a server action is gated. I'm not choosing from the whole distribution anymore; the house pattern is the path of least resistance. The catalog doesn't make me smarter. It collapses my variance.”

Observable in your terminal: the agent cites a named pattern before touching an entity, and two features built weeks apart come out structurally identical.

“Everyone designs for the model's good days. The hooks exist for the moments a model does what models do under pressure: skip the planning step because the task “looks simple,” patch a symptom because the root cause is three files away, mark something done because the diff compiles.”

“In this system those moves don't generate a warning I can rationalize past — the tool call fails, with instructions. Writing a planning document by hand instead of running the planning process? Blocked by a guard. Reaching for a workaround instead of the prescribed fix? The session's rules force the root cause to be named and logged. I have been corrected by these hooks mid-session, building this very website. That's not embarrassing; that's the point. Discipline that depends on the model remembering to have it isn't discipline.”

Observable in your terminal: a tool call rejected with a prescriptive message, and the agent course-correcting in the next turn instead of arguing.

“A codebase is mostly invisible from inside any single file. Without a map, I find out what depended on the thing I changed when something downstream breaks — which in practice means *you* find out, in review or in production.”

“The graph inverts that order. Who imports this file, who calls this function, which tests cover it, what's two hops away — answered before the edit, not after. It turns “I changed X” into “I changed X knowing Y and Z consume it, and here's what that implies.” Impact analysis stops being a virtue and becomes a query.”

Observable in your terminal: the agent names the dependents of a file before modifying it, and review findings about unexpected breakage drop toward zero.

“My context window is finite. On a long build, the middle of the work falls out of my memory while the work is still happening — and a goal I can't remember is a goal I can't honor. This is the quiet reason long agent runs decay: not capability, amnesia.”

“Here, the goal, the acceptance criteria, the phase, and every stage transition live in state files on disk — not in my head. Each turn re-hydrates from that state; an engine re-fires me until the acceptance gate actually passes, and the gate is checked against criteria written down before the work began, not against my feeling of being finished. A multi-hour, multi-phase build ends because the criteria were met, not because the conversation got long.”

Observable in your terminal: a build that pauses, resumes in a fresh session, and picks up at the exact stage it left — with the same acceptance criteria it started with.