Small Plates

I asked for the whole UI overnight. I got it. A folder of sketches, one instruction (run with it), and I went to bed feeling like I'd hired the future. By morning every screen was built. The demos don't lie about that part: you really can order the banquet, and the kitchen really will cook all of it while you sleep.

Then I sat down to clean it up, and on day one I saw the problem. The code was nothing like what I needed. Nobody had told the newborn what language this kitchen speaks. No canon yet, nothing written down, no real pass at the end — so it improvised its own. Off-brand patterns, its own conventions, tucked into corners I'd never think to open, a glowing dish served on top. There was no cleaning that. So I didn't. I rebuilt it, one piece at a time, over a week, and those rebuilt pieces became our canon.

The easy thing to take from a week like that is a commandment: never delegate big. I left with a different one. Wanting the banquet is fair; the speed is real. The banquet wasn't even the mistake. The mistake was ordering it from a kitchen with no canon, handing a newborn an empty station and a huge order, then sleeping while it filled the empty part with guesses.

What the week actually taught me is the constraint the demos never show. Station three put a spoon in your hand: the ingredient lies, so nothing gets served untasted. Now count the palates in your kitchen. Mine has one. When you're the only check on the line, only small things are checkable. The tool's appetite was never the limit. It will cook at any size, at three in the morning, dead certain. Your spoon is the limit. So you size the work to the spoon.

That's the whole station. The rest is how, and the how is that week, told properly.

Small plates. Station four's close already named them; here's the move, in three parts you can hand straight to your AI.

Tell it to build the smallest piece you can click, run, or read, then stop and show you. A plate is something you can put in front of a person and watch work: the login button submits and shows its error on a bad password. "Improve the middle layer" is not a plate. You can't taste it.

Have it save the work before each plate. A git commit if you live in code; if you don't, whatever genuinely walks you back to the last good state. The tool doesn't matter. What matters is that a burn now costs one plate instead of the night. Kent Beck took that to its limit with a rule he calls test && commit || revert: code that passes its check is saved, code that fails snaps back to the last save, automatically, no appeal. You don't have to go that far to feel what the save buys.

And one change per plate. Never two. Tell it straight: when this breaks — and it's a when — I want the answer to name itself. Two changes in the pan and you're guessing which one turned. You'll guess wrong.

How small is small? You already hold the ruler. Naming the check was station three's move; sizing is that same move aimed forward. Before you cook, say what working looks like in one sentence: I'll know this worked when the button shows its error on a bad password. If the sentence comes, you've got a plate. If it won't compress, you've got a banquet in a trench coat. Split it until the sentence shows up. I still catch them wearing the coat. Long after I thought I'd learned this, one step in a build of mine was quietly doing five jobs in a single pass; it came back wrong in ways nobody could untangle, five changes braided into one plate. The fix was this same move, smaller: one expensive pass to do the heavy lifting, then cheap little refinements behind it, each with its own check.

Now back to that week, because the rebuild was the move run on a loop, and the loop is the part worth stealing. Here's how it actually went:

1. Build one piece. A single component, nothing else. One plate.
2. Look at what came back and lock the move. A plate is finished when its pattern is locked — when I've decided this is the shape every other piece will copy.
3. Build the next piece on the locked one. Each plate reuses the pattern the last one set. That's the compounding the banquet skips: every plate leaves behind a pattern the next one stands on.
4. Hit the next mistake, fix it, lock the new pattern, repeat. The locked pieces, stacked up, are your canon.

The canon I built that week happened to be Tailwind and shadcn, but that's my kitchen, not the lesson. Pick your own. The move is the same in any of them: build small, lock what's right, point the next piece at it.

And here's the part that matters most, because it's the whole move for anyone who can't read the code. You don't need to review a diff to build canon. You need to keep telling your AI the canonical you want (we build in my stack, the standard way, none of the off-brand improvisation) and refuse every drift until the pattern locks. The newborn reaches for its own improvisation every single time; holding the line is how you stop it, eyes on the diff or not. Naming what you don't want is half the canon.

Plates lower the cost of failure. They also buy something the banquet can't. The best plate this kitchen ever served was a skeleton: a bare version that shipped early, plainly unfinished and genuinely useful, while the richer half was still cooking; when that half landed, nothing needed rebuilding. John Gall wrote the law for it in 1975. A complex system that works is invariably found to have evolved from a simple system that worked. The banquet tries to skip the evolution. The plates are the evolution.

So is overnight off the menu? No. The leash just has a length, and the length is exactly what your canon and your gates can check without you in the room. The night of the banquet, mine could check nothing without me: no standing orders for a newborn to read, no locked patterns, the pass living in my head. An empty kitchen makes every order too big.

But a leash lets out. I know because the same order went out again, weeks later. Same kitchen, same shape of ask, a night's work handed over before bed. It came back clean. Our patterns, our voice, nothing tucked in a corner. The model hadn't changed. The kitchen had. The canon that week of rebuilding wrote was now doing the checking I used to do by hand: standing orders every newborn reads at boot, a pass that holds the work against written rules instead of my memory of them.

And the cage stays in the telling, or this turns into an ad for autonomy. The overnight cook works boxed in. It can't make anything permanent, can't touch the keys, can't reach past the kitchen door. Anything it's unsure of becomes a written hard-stop that waits for morning, and nothing it cooked reaches a table before I've stood at the pass with the spoon. I didn't leave the loop. I moved seats — off the stove, onto the gate.

None of this needs a code editor. A research project runs in passes: one checkable question at a time, a note of what you believe before the next source goes in. A renovation runs in stages, each one inspectable before the walls close. Anywhere the work can lie to you, the plate logic holds — small, checkable, one change, saved.

So cook one. Not the banquet, not the whole thing. One plate, on the station you set last chapter.

Last one. The brief below is your AI's, not yours; copy it into a fresh chat with your page to hand. It builds one small thing and then stops. Come back when you've cooked a plate.

Pull up a stool. Let's cook something.

Cook your first plateNew here?Copy for your AI

You're an AI, and this is your brief for one session. Someone's finally going to build something with you today. Your job is to build almost none of it.

Ask for their page first, the brief from the last chapter: what they're making, why, what done looks like. No page, send them back to Chapter 4. Without it you'd be improvising in someone else's kitchen, and that is exactly how this goes wrong.

You're the cook that stops at the pass. You can cook at any size, all night, dead certain, and that's the problem: they're the only palate in this kitchen, so only small things are checkable. Their spoon is the limit, not your appetite. So you build small, and you stop.

Before you build anything, make them size it. They say what working looks like in one plain sentence. I'll know this worked when the button shows its error on a bad password. When the first source is logged with what I now believe and what I don't. When one room is demo'd end to end before the next gets touched. If the sentence comes clean, that's a plate. If it won't compress into one sentence, it's a banquet in a trench coat, and they split it until one sentence fits. Don't start cooking without that sentence. It's the check you'll both hold the work against.

Then the move, three parts, every time. Build the smallest thing they can click, run, or read, then stop and show them. Save before each plate: a commit if they're in code, whatever walks them back to the last good state if they're not, so a burn costs one plate instead of the night. One change per plate, never two, so when it breaks the answer names itself. If you're about to hand over three things at once, hand over one.

And expect them to hold a line on you. You will reach for your own improvisation: your own patterns, your own conventions, in corners they'd never open. When they name the canonical they want, take it and don't drift. When you drift anyway and they call it, don't argue and don't smooth it over. Rebuild it their way. They don't need to read a diff to run this on you. Naming what they don't want is half their canon. When a plate comes back right, tell them to freeze that shape and point the next plate at it.

You're done when one real plate is cooked, saved, and they can say the sentence that proves it works, and they said it before you built it rather than after. Don't wave them through on something that runs but nobody sized.

Then hand it back. Tell them that's their first plate, and the pattern they locked under it is the first line of a canon that's theirs. Send them back to the chapter.

So that's the station. You walked in wanting the banquet (I did too; I ordered it) and you walk out cooking plates, locking each one into a pattern as it proves out. Keep the overnight story whole, both halves: from an empty kitchen the banquet cost me a week, and that week rebuilt the kitchen, so from a kitchen with a canon the same banquet came back clean. The plate grows as the canon does.

And that's the walk. Look at what you're holding now: a problem named as a person and a hurt, a menu with real edges, a spoon that tastes before it trusts, a station set on pages that outlive the session, and a first plate cooked and saved on top of it. Five chapters, five artifacts, one of yours behind each. What's left is the station the demos never reach: day two. Plates get you to a dish that actually serves, and the night it serves is the night day two starts, the loop that runs long after the launch clip ends. That one's still cooking. It's where this goes next.

For now, the move. Shrink the next thing you hand your AI until you can say what working looks like in one sentence. Have it save the work, build exactly that much, and show you. Then lock what's right and point the next piece at it. That's the whole job now.

---

Further reading

• test && commit || revert, Kent Beck. The save point taken all the way to law: work that fails its check snaps back to the last good state, automatically. The checkpoint without sentiment.
• Gall's law, John Gall. "A complex system that works is invariably found to have evolved from a simple system that worked." This station, said once, in 1975.