Design Philosophy for AI Interfaces

while (world) { observe(); infer(); hallucinate?(); self-correct(); } while (world) { observe(); infer(); hallucinate?(); self-correct(); } while (world) { observe(); infer(); hallucinate?(); self-correct(); }

001101 010011 sigil::bagua seed::entropy trace::mechanical awe::human 001101 010011 sigil::bagua seed::entropy trace::mechanical awe::human 001101 010011 sigil::bagua seed::entropy trace::mechanical awe::human

temperature=0.92 top_p=0.95 sampler=stochastic runtime=deterministic user=astonished temperature=0.92 top_p=0.95 sampler=stochastic runtime=deterministic user=astonished temperature=0.92 top_p=0.95 sampler=stochastic runtime=deterministic user=astonished

☰☱☲☳☴☵☶☷ oracle != truth ritual == interface meaning <- interpretation ☰☱☲☳☴☵☶☷ oracle != truth ritual == interface meaning <- interpretation ☰☱☲☳☴☵☶☷ oracle != truth ritual == interface meaning <- interpretation

seed = hash(question + state); noise = sample(temperature); pattern = deterministic(seed, noise); if (human_can_track === false) mark("mystic"); return explainability_gap(pattern); seed = hash(question + state); noise = sample(temperature); pattern = deterministic(seed, noise); if (human_can_track === false) mark("mystic"); return explainability_gap(pattern);

## Not a person, still persuasive - interface implies intention - language implies confidence - user infers agency => design for interpretability ## Not a person, still persuasive - interface implies intention - language implies confidence - user infers agency => design for interpretability

cast.bagua = pickTrigrams(seed); cast.moonBlocks = deriveHexagram(seed); cast.fortuneSticks = burnModel(intensity); cast.scapula = generateCracks(seed); return readable_fiction(cast); cast.bagua = pickTrigrams(seed); cast.moonBlocks = deriveHexagram(seed); cast.fortuneSticks = burnModel(intensity); cast.scapula = generateCracks(seed); return readable_fiction(cast);

{ "observe": true, "decide": constrained, "act": reversible, "measure": behavior, "learn": weekly } { "observe": true, "decide": constrained, "act": reversible, "measure": behavior, "learn": weekly }

def perceivable_randomness(system): return complexity(system) > attention_budget if perceivable_randomness(llm): user.labels_output = "fate" def perceivable_randomness(system): return complexity(system) > attention_budget if perceivable_randomness(llm): user.labels_output = "fate"

[trace] t=02:13 system murmurs [trace] tokens fall like ash [trace] certainty simulated [trace] mechanism remains [trace] human names it chance [trace] t=02:13 system murmurs [trace] tokens fall like ash [trace] certainty simulated [trace] mechanism remains [trace] human names it chance

Most AI UX fails for one reason: we ask users to trust invisible decisions.

My design philosophy is straightforward:

make intent visible
make uncertainty legible
make next steps obvious

Reduce cognitive tax

If users need to decode your interface before doing their task, you lost.

I design for:

clear starting points
constrained choice where helpful
progressive disclosure for complexity

“Powerful” UX is often just compact confusion.

Show work when it matters

Not every output needs chain-of-thought style exposition. But users need enough to answer:

Why did I get this?
What assumptions were made?
What can I do next?

That’s trust UX.

Constrain before you personalize

Teams rush to personalization early. Usually that’s backwards.

First build:

stable core workflow
high-confidence baseline behavior
clear failure handling

Then add personalization with measured blast radius.

Design for refusal and ambiguity

AI products need intentional states for:

missing context
low confidence
policy conflicts
ambiguous user goals

If your only state is “answer,” quality will drift.

The visual layer should reinforce the interaction model

I care less about trendy components and more about behavioral semantics:

confirmation moments
confidence signals
reversible actions
clear ownership of final decisions

AI UX should feel calm, not performative.

A useful litmus test

After a session, can a user explain:

what happened,
why it happened,
what to do next?

If yes, design is doing its job.