A design practice where prototypes cost hours.

I learned gates in email, where one broken render reaches three million people. My email platform runs nine agents behind a ten-point automated gate: rendering, dark mode, accessibility, file weight, spam signals, and more. Work ships when the checks pass, not when an agent sounds confident. The same idea generalises to product design. A generated screen passes through:

• 01Token compliance: no colour, spacing or type value outside the system.
• 02Contrast and accessibility: WCAG AA, focus states, labels, alt text.
• 03Spacing rhythm: the grid holds; drift is a failure, not a style.
• 04Voice: copy checked against the register, banned words caught.
• 05Pattern reuse: an existing component beats a newly invented one.
• 06A judge pass: a second model critiques the screen against the brief before a human sees it.

The gate is what makes speed safe. Without it, generation is just a faster way to drift off-brand.

A design system tells you how things should look. It rarely tells you why, and it never tells you what happened next. The third layer of the practice is a design knowledgebase, part of the system itself: every decision goes in as a record with its context, the choice, the alternatives rejected and on what grounds, the number that will judge it, and, once the live test runs, what actually happened.

• 01
  Decide, on precedent

  Before an agent or a designer proposes a checkout pattern, they query what checkout decisions came before, and what the data said. The gate cites precedent. Nobody decides blind.

• 02
  Test, and write back

  The live test's result lands on the record that made the claim. A decision without an outcome attached is still a hypothesis, and the knowledgebase says so.

• 03
  Evolve, per audience

  Outcomes are logged against who they were measured on. What earns trust with commuters can read as noise to the once-a-year traveller, so patterns become defaults where they are proven and get flagged where they failed. The UX evolves on evidence, and the system keeps it reading as one product while it does.

This is not automated taste. The knowledgebase never decides; it makes sure no one decides blind, no one rejects an idea twice for unwritten reasons, and a new designer inherits the team's judgement, not just its components. The notes beside each prototype's glass are entries from exactly this kind of record, and the pattern already runs in my email platform, where a retrieval-backed knowledge module answers from the team's own accumulated craft.

• 01
  Frame the bet

  What do we believe, what would change our mind, and what number decides. Written before anything is drawn.

• 02
  Diverge in Figma

  Boards, not pixel-perfect mocks: competing directions, flows and attach points, cheap to make and cheap to kill. This is also where stakeholders walk the thinking.

• 03
  Converge in code

  Agents read the system, and the Figma file through its API, and build the surviving directions as working prototypes. Hours, not sprints.

• 04
  Gate it

  Every variant passes the automated checks before a human reviews it. Reviewers spend their taste on decisions, not on catching drift.

• 05
  Live-test and decide

  Fake doors, probes and real flows in front of real people, against the number from step one. Then invest, iterate or kill, cheaply and without ceremony.

Figma stays what it is best at: thinking out loud, together. Code becomes the medium of proof. The handoff between them is agent work, not a week of a designer's life. And every decision, with its result, lands in the knowledgebase, so the next bet starts smarter than the last one did.