← Craig Stapley✕
Essay · 5 min read

I stopped trusting myself to decide what goes where

AI builds a screen in seconds. Deciding what belongs at the top is still the whole job, and I kept copying that decision from the last project without ever making it. So I built a tool that won't render until the hierarchy is actually earned.

Cargo-cult hierarchy

Pattern I caught myself doing across three projects:

New screen. Look at the closest prior design. Copy its field order. Tweak spacing. Change a color. Call it done.

That field order was never actually decided. Not the first time, not in the redesign, not in the redesign of the redesign. Each version inherited the order from the one before and called inheriting it "designing." Nobody chose it. It just accrued.

Cargo-cult hierarchy. It has every appearance of design work and none of the deciding.

Same data. Same screen. Two hierarchies. Only one of them was earned.

What the compiler does

Structured prompt pipeline that blocks rendering until hierarchy is earned from first principles.

Four stages. Each produces output. No output, no next stage. That's the whole mechanism.

Stage 1: Inventory

List every field, control, metadata that could exist on this screen. No judgment. Just what's available.

Catches a silent failure: designs that inherit only the fields that were on the old screen, even when the use case changed. Compiler forces me to say what's actually available, not just what was there last time.

Stage 2: Intent Mapping

For each field, three questions:

  • Whose job is it doing? Mine, the user's, the business's, compliance's?
  • When does it matter in the flow? Before, during, after the primary action?
  • What breaks without it? (If the answer is "nothing," delete it.)

Answers are ugly. Most screens have three or four business/compliance fields pretending to serve the user. The compiler surfaces them.

Stage 3: Rank

Rank by user intent, not by how the database orders them. Backend field order reflects schema design. Not human priority. Most screens are still organized by the database schema by accident.

Rank everything. Highest intent at top. Weakest at bottom. Explicit comparisons. "Field A beats B because [reason]." No ties.

Ties are where cargo-cult returns. "They feel equal" means "I haven't decided." The compiler kills ties.

Stage 4: Render

Now you draw. Hierarchy is a committed spec, not a feeling. Primary action sits where the top-ranked element lives. Metadata goes below the interaction zone. Compliance fields either hide behind a disclosure or stay invisible until the moment they matter.

Real example

GiveCampus contact report form. Original hierarchy (inherited three times):

  1. Visit date
  2. Donor name
  3. Topics discussed (checkboxes)
  4. Next steps
  5. Follow-up date 6-14. Nine more fields
  6. Notes (free text)

Compiler run on the same data produced different ranking:

  1. Notes. The gift officer's actual job is documenting what happened. Everything else is structured exhaust.
  2. Next steps. Only field that changes what happens next.
  3. Donor name. Context. Pre-filled.
  4. Visit date. Pre-filled. Rarely edited.
  5. Everything else: secondary panel or gone.

Redesigned form starts with free-text: "How was the visit?" Rest is below. Compliance lost zero fields. The form got honest about whose job it's really serving.

Why tool instead of checklist

I tried hierarchy checklists first. They don't work, and the reason is nastier than "I forgot." A checklist only fires if you notice you're skipping it. But copying without deciding doesn't feel like skipping. It feels exactly like working. That's the trap. The failure hides inside the sensation of being productive.

A gate doesn't care how it feels. You cannot render the screen until the hierarchy artifact exists. The question flips from "did I think about hierarchy" (which I'll always answer yes to) to "does the artifact exist" (which is either true or it isn't).

That's the whole project now: turn discipline into a gate. Discipline is a thing I run out of by 4pm. A gate doesn't get tired.

AI's actual role here

AI can build a button, card, whole screen in seconds. What it can't reliably do: tell you if the hierarchy it made is right for this user in this state at this moment.

Hand a vague prompt to any generator. Get back a screen whose hierarchy blends everything similar in its training data. That hierarchy isn't earned. It's averaged.

Compiler is the pre-work that makes generation useful. Run it first. Give the AI the ranked intent output. Now generation has a target. Now you're collaborating instead of hoping it reads your mind.

Get the compiler

Full Design Compiler skill is on the tools page. Stage prompts. Rubric. Templates. Use it with any AI tool or run it in your head. The mechanism matters. Hierarchy must be earned. The tool just makes skipping it feel as wrong as it actually is.