The Steering Problem: AI, Tech, and Better Human Behavior

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 software already shapes behavior. The question is not whether we steer people. The question is whether we do it transparently, responsibly, and with user agency intact.

I call this the steering problem.

What I mean by steering

Steering is any product decision that changes what users notice, choose, repeat, or avoid.

That includes:

what gets surfaced first,
how friction is distributed,
how feedback is timed,
and what “success” looks like in the UI.

In AI products, steering becomes stronger because the interface can adapt language and suggestions per user state.

Good steering vs bad steering

Mode	Signature	Result
Good steering	explicit intent, user control, measurable benefit	more agency over time
Bad steering	hidden nudges, compulsive loops, vague outcomes	dependency and distrust

If users cannot explain what your system is trying to optimize in their behavior, your steering model is probably too opaque.

My practical framework

I design behavior systems around four checks:

Direction: what behavior are we trying to increase or decrease?
Consent: does the user understand and choose this loop?
Feedback: is the signal immediate enough to learn from?
Exit: can users override, pause, or reject the loop?

If one of these fails, the system is likely manipulative or noisy.

Bonzen and Divine Machine sit on one spectrum

I treat these as related but different projects:

Bonzen is behavior tech: check-in, guided reset, reflection, next action.
Divine Machine is art/critique: a ritual interface that makes deterministic inference feel oracular.

Both ask the same core question: how do interfaces shape human interpretation and action?

Bonzen answers with practical daily behavior loops. Divine Machine answers with a philosophical mirror.

Product principle: steer toward self-authorship

The goal is not “perfect behavior.” The goal is better self-authorship.

That means helping users:

notice patterns faster,
recover from bad loops sooner,
make one better next decision.

I distrust products that claim total transformation. I trust products that improve next-step quality repeatedly.

How I evaluate behavior products

I look at second-order effects, not just engagement:

Does user clarity increase over repeated use?
Does time-to-recovery improve after setbacks?
Do users become less dependent on the app over time?
Can they transfer learned behavior off-platform?

If the answer to the last two is no, you may be building reliance, not growth.

Final take

AI can be used to exploit attention or to improve agency. Both are technically possible.

The difference is product intent, interaction design, and accountability.

That is the work I care about: building systems that help people steer themselves better.