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 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.

Next station is the one the demos never reach. Plates get you to a dish that actually serves, and the night it serves is the night day two starts. That's 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.

Grab a beer. Pull up a stool.

---

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.