A design operating system for AI-native product work
When AI could generate product work faster than any team could verify it, I built the operating model, governance, and review surface that kept a team of designers and AI agents honest, and made every change inspectable before it shipped.
Building a system that makes AI-native design trustworthy
Operating model
Designed the roles, durable memory, and evidence gates that let designers and AI agents produce product reasoning (not just output) with source-cited state on disk instead of disposable chat.
Governance
Owned canonical pattern stewardship and a proposal-to-apply contract, so no agent could silently change a screen. Every change arrived reviewable, with a clear state.
Scaled to other leaders
Ported the operating model to a second design team on a separate product, kept structurally compatible so the two efforts could converge.
The hard problem of AI-native design isn't generating screens. It's trusting what gets generated.
Tebra's mental-health product was AI-native in the deepest sense: the experience is assembled at runtime from commands, retrieved data, and model judgment, not laid out as static screens. That broke the normal design toolkit. The most important parts of the product (invisible runtime decisions, model-quality thresholds, the trace from clinical evidence to requirement) had no wireframe to point at.
My mandate was to make that new kind of product designable and governable: to give a team a way to produce AI-native work quickly without losing the ability to inspect, question, and trust it before it shipped. I led it as an operating model first and a tool (Clarity, live at clarityux.app) second.
AI made it trivial to produce convincing product artifacts. It did not make them correct. Speed created a new failure mode: work that was structurally valid (validated specs, successful mutations, clean screenshots) and still wrong for the provider who had to use it.
- Product reasoning lived in chat and markdown, and evaporated between sessions.
- Agents could change screens directly, so "fast work" and "untraceable work" became the same thing.
- Structural success ("the spec validated, the mutation applied") kept getting mistaken for product quality.
- There was no shared surface where a human could tell an idea from a dry run from a committed change from a final decision.
I built two things that worked as one: a team and a surface. That team was a set of named AI specialists (research, strategy, design, PM, engineering, plus a director) each with durable memory and one question to own. The surface was Clarity, where their proposals became inspectable, reviewable changes instead of free text. The team is the brain; Clarity is the hand and the eye.
Make the vault the brain
Durable, source-cited evidence and decisions live on disk; the model is interchangeable workforce. Reasoning survives the session that produced it.
Constrain the legal moves
Agents propose through a typed contract and a deterministic apply engine. Nothing mutates a screen silently; every change arrives as a reviewable proposal with a clear state.
Require rendered proof
A validated spec, a successful mutation, a screenshot that exists. Those are diagnostics, not success. Work isn't done until the rendered experience is usable for the provider.
The decision I'm proudest of came from a failure. An early build produced perfectly valid artifacts and a provider experience that still wasn't good enough. I treated that as a process defect, not a one-off: I separated the people who build from the people who verify, made rendered screenshot-and-precedent proof a hard gate, and wrote "rendered usefulness beats structural validity" into the operating rules. Then I scaled the model: coaching other design leaders on a separate product onto the same method, with the systems kept structurally compatible so the work could merge.
Judgment under ambiguity
Set the non-negotiable bar (usable rendered experience over structural validity) and rebuilt the process around it after a build passed every check and still failed.
Governance as a leader
Owned canonical pattern stewardship and review-as-policy: structured, role-based review became a shipping gate, not an afterthought.
Disseminated the model
Coached other design leaders onto the operating method on a parallel product: proof it transfers beyond me.
From PRD to prototype: humans and agents in one workspace
A validated spec and a rendered screen are facts, not success. The provider's experience is the only bar that counts.
Rendered usefulness beats structural validity.
An operating model, not a tool
Turned AI-native design from disposable chat into durable, inspectable product reasoning: roles, memory, evidence gates, on a governed path from proposal to applied change.
A quality bar that held
Made rendered, provider-usable proof a hard gate, so structural success could no longer masquerade as product quality.
Proven beyond one person
The method was adopted by a second design team on a separate product: evidence the system transfers, not just a personal workflow.