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.
Product Design
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.
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.
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. The team was a set of named AI specialists — research, strategy, design, PM, engineering, and 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.
An operating model, not a tool
Turned AI-native design from disposable chat into durable, inspectable product reasoning: roles, memory, evidence gates, and 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.