No One Knows What They Want

You described what you wanted. The AI listened, agreed, went away, and came back with something built — confidently, completely, and not what you meant. Not broken; you could run it. Wrong in the more expensive way: it had quietly decided what you wanted, filled every gap you left with a guess, and committed. Now you’re staring at code that answers a question you never asked, and the cost of saying no, not that is most of the work it just did.

It’s tempting to read this as the AI not being smart enough. It isn’t that. The sharper diagnosis isn’t mine — I got it, like most of what now works in my setup, from Matt Pocock, who reaches back to an old line in The Pragmatic Programmer: no one knows exactly what they want — not your stakeholder, not you. There’s a gap between the thing in your head and any description of it you can hand over, and the AI, fast and literal and eager, pours concrete into that gap before you’ve noticed it’s there. The failure isn’t intelligence. It’s that you and the machine never shared the same picture of the thing — and you started building anyway.

That picture has a name. Matt has another old book for this part — Fred Brooks’s The Design of Design — and a term from it: the design concept, the shared, still-forming idea of a thing that lives in the heads of the people building it, not in any file they produce. And the property that trips everyone up is this: you can’t hand it over. A design concept isn’t a deliverable. No spec captures it and no ticket pins it down; the best a written document can manage is to photograph it from one angle, and the photo starts going stale the moment you take it. So “aligning with the AI” was never really about writing a crisper prompt or a tidier spec. The alignment has to happen before there’s anything written down at all.

Almost everything about the tooling pushes the other way. Point a coding assistant at a task and its first instinct is to make something — a plan, a file, a scaffold. Claude Code’s plan mode, which I otherwise like, does exactly this: ask it to think and it hurries to write the plan down, often before I’d agree we’ve settled anything. A generated plan is seductive precisely because it looks like alignment — it has headings, it sounds sure of itself. But a plan written before you share the design concept just dresses a guess up as a decision.

I’d love to tell you I’m above this. I’m not. The planning behind this very blog — the sessions that produced the PRD and issues this series keeps pointing back to — was asset-eager in exactly the way I’m describing. Before we’d pinned down what the opening post even needed to say, we were busy speccing out diagram tooling, MDX callouts, and hero images: infrastructure for a post that didn’t exist yet. We caught it, cut all of it, and settled on something deliberately plain — but the effort was already spent, and we wrote the slip down as a wart so we wouldn’t pretend it hadn’t happened. Knowing a failure mode doesn’t make you immune to it. That gap — between knowing better and reliably doing better — is what a skill is for.

The skill is called grill me, and the first surprising thing about it is how little there is to it. Three sentences:

Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one by one. And if a question can be answered by exploring the codebase, explore the codebase instead.

That’s the whole thing. No template, no framework — three instructions, and they invert who’s driving. Normally you prompt and the AI produces; here the AI becomes the interrogator and refuses to stop. It asks where a thing should live, then what depends on it, then what happens at the edge case you hadn’t considered — ten, thirty, fifty questions deep, until it can’t find another seam between the picture in your head and the one it’s assembling. What you hand it isn’t a specification. It’s a willingness to be questioned until there’s nothing left to disagree about.

The middle sentence is the one doing the real work. Walk down each branch of the design tree, resolving dependencies between decisions one by one — that’s the difference between a chat and a design. A design tree is the fan-out of questions hanging off any choice: commit to one branch and it spawns the next set; skip a branch and you’ve left a gap for the AI to guess into later. The grilling is what forces you down every branch instead of the one or two you happened to think of.

Take a small decision from this blog: should the lone 2022 post stay in the main feed, or move out of it? Choose move and the tree immediately forks. Move it where — a dedicated archives page? Does an archived post still belong in the RSS feed? In the post count on the home page? And what does answering those do to the tests that assert both? Each answer is load-bearing for the next, and the order isn’t optional — settle the destination before the feed rule and you’ll redo the feed rule. None of these questions is hard on its own. The failure mode is never reaching them at all: discovering the RSS question only after the AI has shipped a feed that still includes the post you meant to retire.

Here’s the move that makes it pay off: only when the grilling burns out — when the AI finally runs out of questions — do you let it write anything down. Now the document is earned, and you hand it down a short chain of skills, each as small as grill me was. One turns the settled conversation into a PRD. The next slices that PRD into issues — thin vertical cuts, each a piece an agent can grab and build on its own while you’re away. grill me → write the PRD → cut the issues: three tiny skills, one unbroken line from a fuzzy idea in your head to merged code, and not a single step along it produces something you hadn’t already agreed to. The order is the whole trick — align, then write, then build. Reverse the first two and you’re back to the wrong-thing problem, only now it has page numbers.

This post is the proof, the same way the blog itself was the proof in part one. What you’re reading ran that exact line. It started as a grilling session — the AI pressing me on what this piece was for, who it was for, which examples earned their place — until the shape stopped shifting under the questions. That became a PRD; the PRD became issues; the issues became this. The argument and the artifact are the same object, which is the most honest evidence I can give you that the order holds.

And it isn’t just this post. I’ll be plain about it, because all of this can read like theory: grill first, align hard, build only after — this is my entire workflow now, the default path for almost everything I make, not a technique I save for the big features. The part I still find a little startling is that something this small just works, this reliably — three sentences that get me and the AI to the same place, again and again. I’m plainly not the only one who’s noticed; the skills repo it comes from is north of 148,000 stars, which is not a number a neat trick earns. Full credit to Matt Pocock for all of it. I’m just reporting from the far end, where it kept being true.

So: before you write code, reach the design concept — and let the grilling get you there, because good intentions won’t. That’s the whole of part two. The failure was building before aligning. The fundamental, decades older than AI, is that a shared design has to exist before a shared document can mean anything. And the skill is what turns that discipline into something you run instead of something you remember to do.

There’s a catch I sidestepped, though. Reaching a shared picture inside one session is one thing. Reaching a shared vocabulary — the same words meaning the same things, every session, across a codebase the AI forgets the instant the window closes — is another problem entirely. That’s the next failure mode: not the AI building the wrong thing, but you and the AI slowly talking past each other. Next time, a shared language — and the skill that keeps it from evaporating.

I met all of this through Matt Pocock — the grill me skill, the design tree*, and the whole move of answering an AI failure mode with an old book. The* design concept is Fred Brooks’s, from The Design of Design*; the design tree Matt traces there too, though he’s honest that he isn’t sure it started with Brooks.*

⌇∘∘∘∘⌇ Kurumulaku — Malabar black pepper from the hills of Kerala. A chance seedling that grew into the spice Rome and Arabia crossed oceans for; still hand-picked off the same shade-grown vines, one green peppercorn spike at a time.