A working set of frameworks I use and teach for building trustworthy AI into enterprise software: how the interaction model changes, the concepts designers need to hold, the UI patterns that emerge, and the prompt scaffolding that gets a team from blank canvas to production.
If A, then B. Always. The interface can assume one shape because the output never varies.
The same input can return different output. The interface has to hold content of varying length, format and confidence — and let the user verify it.
Traditional UX is command based: click a button, navigate a menu, fill a form, and the output is highly predictable. AI introduces intent-based interaction, and every role in the system changes with it.
{{ s.v }}
A probabilistic system will be wrong in public. The design question is not whether it fails but whether the user can see the failure and act on it. I hold four failure modes and require a named recovery for each.
The answer reads clean but the underlying figure does not exist in the source data.
Recovery: every claim carries an inline citation to the row, table or document it came from — verification is one click, never a support ticket.
The model returns a usable answer at 61% confidence with two plausible alternates behind it.
Recovery: show the confidence, show the alternates, and let the user promote one — ranked options instead of a single hidden guess.
The feature is on but the telemetry underneath is too shallow to model.
Recovery: state the requirement in plain numbers, then offer a real choice — a linear projection, or cancel. Never a confident fabrication.
The system resolved an ambiguous request to the wrong metric, period or entity.
Recovery: restate the interpretation as editable chips — metric, timeframe, filter — so correcting the read takes a tap, not a re-prompt.
You cannot design the surface of a system you do not understand underneath. Each concept carries a direct consequence for the interface.
{{ c.b }}
{{ c.u }}
A linear, text-based thread.
Open-ended exploration, troubleshooting, complex querying.
AI folded into an existing action — a “rewrite with AI” affordance surfaced over selected text.
Enhancing a specific user action without breaking focus.
A side panel that watches the workspace and offers real-time suggestions or documentation.
Complex enterprise tools, design software, IDEs.
Background processing that surfaces insights or anomalies automatically, with no prompt at all.
Dashboards, analytics platforms, monitoring tools.
A framework I authored for making a probabilistic feature feel trustworthy inside an enterprise dashboard — from where the trigger lives to how the system degrades when the data is too thin.
Adjust model variables without engineering a new prompt or breaking workflow.
{{ s.b }}
Flip forecasting on for a metric with three weeks of history and the system must say so plainly: AI forecasting requires a minimum of 6 months of historical data to model seasonality. This view contains 22 days of telemetry. Then it offers a real choice — project a linear trend anyway, or cancel — rather than quietly producing a confident, wrong answer.
A reusable prompt pattern for deriving a distribution or comparison visualization. The structure is the point: data, objective, visual preferences, clutter reduction, output format — so the model returns something a designer can actually ship.
Task success and time on task break down the moment two users get two different answers. These are the four signals I instrument instead, and the design decision each one drives.
How often the output ships untouched. A low rate is a prompt-scaffolding problem, not a UI problem.
Average corrections before the user is satisfied. Rising distance means the interface is hiding the variables that matter.
How long it takes to confirm the answer is true. Citations and drill-through are judged on this number alone.
Share of sessions that fall back to a human or a manual export. The honest measure of whether the feature earned its place.
When the system starts acting rather than answering, the design problem shifts from presentation to permission. Autonomy is earned step by step, and every irreversible action needs a gate the user controls.
The agent states what it intends to do, in what order, before it touches anything.
Reads run free. Anything that writes, sends, spends or deletes stops for a human.
Every step is logged, attributable and reversible — the difference between a tool and a liability.