A governed harness for safer agent-assisted product work
An internal product and development system for design-to-build review, dry-run/apply workflows, visual QA, rollback thinking, and release gates.
Built the operating surface that lets a design team adopt agentic tooling without losing control — the exact capability AI-first orgs now hire for.
A typed ScreenSpec contract and a deterministic apply engine mean agents propose, the system validates, and humans decide. Shipped as a production-shaped app, backed by 300+ passing tests.
Moved quality from documentation into enforcement: design tokens, region rules, and visual review the canon won't let you violate.
Clarity is the answer to a question every design org now faces: how do you let AI accelerate the work without letting it quietly erode your craft?
It began inside the Nitro work as a way to author and review AI-native product experiences without letting agents make unbounded changes — and became a production-shaped Next.js app, live at clarityux.app, with a canvas editor, component governance, draft wireframes, review surfaces, agent context, versioned state, and rollback.
The defining decision was to treat agent operation as a governed product surface rather than a chat box. Designers compose on canonical patterns; agents propose changes through a typed contract; validation, visual review, and audit evidence are first-class. It is, in effect, a redesigned design tech stack — the operating model an AI-first design organization needs.
AI could help generate product work quickly, but speed created new failure modes: broad edits, hidden assumptions, fragile state, unclear ownership, and visual drift that looked acceptable in text but failed on screen.
- Design changes needed typed, validated paths instead of broad seed-file edits.
- Design-system constraints had to be enforced, not merely documented.
- AI output needed prompt versions, telemetry, validation, and optional evals.
- Review evidence had to survive beyond the chat where the work happened.
I framed Clarity as a harness: constrain the legal moves, make the agent's proposal inspectable, and require evidence before apply.
Dry run before apply
Every agent-proposed change emits a typed ScreenSpec, validated against shell, region, and component rules before any state changes. A deterministic apply engine — not the model — commits the result.
Make the canon un-bypassable
Principles are enforced at authoring time: drop an incompatible component and the canvas rejects it. You literally cannot compose legacy-SaaS patterns the system doesn't sanction.
One steward, no drift
A single Pattern Steward promotes and deprecates patterns, so the canon stays coherent. Designers propose; review gates for research, requirements, and principles decide what becomes canonical.
For AI design-leadership roles, Clarity is the clearest proof that I understand the operational side of AI-native design — not as theory, but as a working system. I designed and built it end to end: the governance model, the agent contract, the review surfaces, and the steward workflow that keeps a shared design language coherent as more work moves through agents.
Design-to-build review
Structured the path from intent to proposed change to reviewed, deterministic apply — with versioned snapshots and rollback when something needs to be undone.
Visual QA
Treated rendered screens and visual review as part of product quality, not polish at the end — because text-perfect changes still drift on screen.
Stewardship at scale
Built the cross-squad model — health dashboards, proposal queues, deprecation signals — that lets a design org adopt agents without canon fragmenting.
Review, governance, and apply surfaces
The agent could propose. The product had to make review, evidence, and apply decisions explicit.
A shipped, governed product
A production-shaped Next.js app, live at clarityux.app, with a typed agent contract, deterministic apply engine, versioned snapshots, rollback, and 300+ passing tests.
A safer agent path
Moved AI work from unbounded generation to typed, validated, reviewable change — where the canon is enforced at authoring time, not hoped for in a style guide.
An adoption model
A stewardship operating model — review gates, proposal queues, and deprecation signals — that lets a design org bring agents into the work without losing its craft.