Two loops of
code review

The council chapter taught you not to trust one answer. This chapter is the same lesson turned on your own work: do not trust one pass at reviewing it either, and above all do not trust the pass you do yourself right after finishing. You are the worst-placed person to catch your own mistakes at exactly the moment you feel proudest of the work.

There is a real reason for that, and you already met it in the beginner course. A long piece of work, whether it is you writing or a model building, burns through working memory. By the end, all the attention has gone into getting it done, and there is little left for stepping back and asking whether it is actually right. The beginner course called this the smart zone and the dumb zone: fresh context thinks clearly, exhausted context drifts and misses things. The author at the finish line is deep in the dumb zone, and no amount of re-reading their own work fixes that, because they are re-reading it with the same tired eyes that made the misses in the first place.

This two-loop idea comes from Matt Pocock, who teaches it for AI-assisted coding: one loop builds, a separate fresh loop reviews. We are borrowing it and naming our own version of the ritual, because you will use it constantly and it deserves a name you will actually say.

We call it Roast Me. Before you commit to a plan or ship a piece of work, you hand it to a fresh pass and ask it, in plain words, to tear it apart. Not to praise it, not to polish it. To find what is wrong with it while changing it is still cheap. The name is deliberate: you are not asking "is this good?", because a model, like a polite colleague, will usually say yes. You are asking it to roast the thing, which gives it permission to be the blunt reviewer you actually need.

The trick that makes it work is freshness. You do not ask the same chat that just helped you build something to now review it, because that chat is the tired author, attached to its own choices. You open a clean conversation, paste in the plan or the work with no backstory about how proud you are of it, and let a reviewer who has no stake in it look with clear eyes.

Be honest about what freshness buys you. A clean chat clears the model's memory of its own choices, so it stops defending them, and that alone catches a surprising amount. What it does not do is hand you a different mind: the same model in a fresh chat carries the same blind spots that made the work. So a clean chat catches carelessness. For the misses baked into the model's own instincts, send the roast to a different model family from the last chapter.

What comes back is uncomfortable in the useful way. Because you asked to be roasted rather than reassured, and because the reviewer is fresh, it says the things a polite pass would have swallowed. Most of them you can fix in a minute now, and every one of them would have cost you far more to fix after you had committed.

Roast Me is the everyday version you can run in any chat, on anything, right now. The heavier version, the one that earns the chapter title, is for when you are building real software: a dedicated reviewer that runs as its own separate pass with its own fresh context, checks in a stronger model than the one that built the work, and is held to a standard you decide in advance.

Two of those are worth underlining. First, use a stronger model to review than to build. It is the same logic as the ladder from the last chapter, inverted: you can afford a cheaper model for the construction because a more capable one is going to check it, and the check is where you spend for quality. Second, push the standards to the reviewer. Instead of hoping you remember your own rules each time, you write them down once, hand them to the reviewer as its brief, and let it be the one that never forgets. The builder pulls the work forward; the reviewer holds the bar.

The hands-on version of this, a read-only reviewer you set up once and check into your project so it runs the same way every time, needs a terminal and a real repo. You are not there yet in this course, and that is fine. It waits for you in the companion repo under roast-me/, and the terminal chapter and the architecture chapter give you what you need to wire it up. For now, the everyday Roast Me is the habit to build, and it needs nothing but a fresh chat.

The proudest moment, right after you finish, is the worst moment to judge your own work. Hand it to fresh eyes and ask them to be unkind. The sting is cheap now. The miss you ship because nobody roasted it is not.