My Engineering Philosophy for AI Products

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

My default hierarchy is simple:

Clarity
Reliability
Velocity

Most teams accidentally invert this under pressure.

1) Clarity: if nobody can reason about it, it’s already slow

AI codebases get messy quickly because behavior is partly data, partly prompts, partly runtime policy.

I optimize for:

explicit boundaries (input shaping, model call, post-processing)
typed output contracts where possible
visible assumptions and fallback paths

Clean architecture is not style points. It is incident prevention.

2) Reliability: design for bad days, not good demos

AI systems fail in weirder ways than deterministic systems.

I assume:

upstream model changes
intermittent latency spikes
malformed outputs
rate/quotas constraints

So I add:

retries with guardrails
timeout budgets
schema validation
sane fallback responses

Users remember how your product behaves when it fails.

3) Velocity: speed with legibility

Shipping speed is not about heroics. It is about reducing decision drag.

The most useful patterns I’ve found:

thin vertical slices
explicit acceptance criteria
one source of truth for evals
instrumentation before scale

The goal is not to be “fast once.” The goal is to be predictably fast.

What I avoid

premature multi-agent complexity
giant internal frameworks nobody asked for
hidden prompt mutations in random files
metrics dashboards with no product interpretation

What I optimize for in teams

I want teammates to answer quickly:

what changed?
why did it change?
how do we know it improved?
how do we revert if needed?

If these questions are easy, delivery quality compounds.

The rule I come back to

Write code so future you can debug it at 2:13 AM with incomplete context.

That is the standard.