UX Review Process

Each step runs in its own fresh session with no memory of the one before. That isolation is the load-bearing trick: material can be deliberately withheld until the stage that should see it. Process state isn't tracked in a tool; it's tracked by which numbered files exist in the folder.

1. 01

   Objectives→ 01-Objectives.md

   Read the transcript and pull only the high-level goals and process decisions, resisting the detail, because specifics are a later stage's job. Classify the project, pick the format, and name exactly one primary user. A deliverable without a single named primary audience is not done.

2. 02

   Data relevance→ 02-Data-Relevance.md

   Check every intended number against the shared platform data inventory: measured, partial, or can't-do. The inventory is shared ground truth across every stream, so impossible asks get formally declined here instead of quietly dropped later.

3. 03

   Narrative wireframe→ 03-Narrative-Wireframe.html

   Build the story spine first (the questions the primary user asks, in the order they ask them), then hang a first visual on it. The transcript is deliberately withheld, and for redesigns so is the old design: the first visual grows from narrative, not from the existing layout.

4. 04

   Spec + detail layering→ Spec-Wireframe.html

   The full transcript enters for the first time, plus the old design for updates. Complete feedback coverage gets layered in as tags, the review layer, data-basis lines, and open calls: the ideal pulled toward the achievable.

5. 05

   Persona review→ Persona-Review-Audit.md

   A panel of context-free reviewer personas audits the spec in parallel. Findings get triaged through a hard gate (implement, escalate, or dismiss with reason), and nothing moves to build until the audit comes back clean.

After step five, the reviewed spec seeds the build in the design system: a fast handoff, because the build starts from documented intent instead of a blank canvas.

Every spec faces a panel of written reviewer characters before it can become UI. Each persona is spawned as its own parallel, context-free agent: it gets its persona file, a conventions card, and the file path. No project history, no transcript, no other reviews. It can't know our excuses, and it can't be polite.

Every finding then passes a triage gate and becomes exactly one of three things: implement (a numbered TR decision with rationale), escalate (a red bracket and a numbered open call, never an invented answer), or dismiss with reason (recorded, so even the dismissals are auditable).

Every claim in a wireframe wears a colored tag pill; hover it and the verbatim sentence from the meeting appears. Design decisions get their own pills, so the design is the decision log. A fixed "Show review layer"toggle makes one file serve two audiences: it opens clean for stakeholders, and one click restores tags, legend, coverage table, and rationale. Takeaway strips sit under every chart, written in the audience's own voice; weak ones get flagged with a why-weak-and-fix note. Red brackets mark data that genuinely doesn't exist yet, each pointing at a numbered item in the Open Calls box, where undecided things stay red, named, and dated until somebody resolves them.

Everything in this walkthrough is fictional by design: a made-up feature ("Stale Work Radar"), a made-up kickoff, made-up quotes. That means the process can be shown end-to-end with nothing to redact. The pipeline ran exactly as it does for real streams.

What goes in:a 47-minute recorded kickoff. A dev lead has watched two branches sit untouched for nine days and get caught at standup right before a release cut. He wants a ranked list: "the list is the product." Leadership wants a dollar figure next to every dying branch. Nothing is decided cleanly: "stale" has no definition, one ask is flatly impossible, and nobody settles whether individual names show. This mess is the normal starting condition.

Steps 1–4distill five objectives and one audience, declare leadership's "cost avoided" number non-capturable by policy, catch two parts of the data documentation contradicting each other, build the ideal with the transcript withheld, then layer back ninety-plus tag pills, seventeen coverage-checked source asks, and twenty-eight numbered decisions.

Step 5is where it gets uncomfortable. Five context-free reviewers land twelve consensus findings. All four technical personas independently hit the same flaw: a precise, trended headline count of "12 stale candidates" sitting on a definition of "stale" the page itself admits is undecided. And the Developer persona finds what nobody in the meeting raised: the surface shows a lead your local, never-pushed commits, and never tells you what it says about you. Triage: 14 implemented, 15 escalated, 2 dismissed with reason.

The real work streams below each show the full chain: why the project started, the wireframes, the review, and what changed.