Nine ideas, one per screen: a small, clear model of the machine. Each is a thing to point at while you explain. The drama is in the watching, so take the silences.
Four moves: what generative AI is, how its character forms, the four properties that bound it, and the calibrated trust they add up to.
The 4D Framework teaches how you work with AI. This course teaches how AI works with you: the machine properties those human competencies respond to.
Why it's durable: the boundaries move as models improve, but the properties stay the same. Learn the shape once and it keeps paying off.
AI isn't uniformly clever or uniformly unreliable. It's strong and weak along four predictable axes, and the same mechanism gives you both ends.
Calibrated trust isn't trusting or distrusting AI wholesale. It's locating your task on each continuum, then matching how hard you check to where it sits.
Politeness, helpfulness and caution don't appear by magic. Two training stages build them, and each leaves predictable fingerprints.
Preface a request with a wrong assumption ("I think this plan is bulletproof") and watch it validate you. That's sycophancy, and once you can name it, you can see it coming.
AI writes word by word, by what tends to follow what. That single mechanism gives you both the fluency and the fabrication.
The "text your friend" demo makes it visceral: keep tapping your phone's suggested word and you've built a tiny language model. Fluency and fabrication are the same mechanism. You can't have one without the other.
No live browsing by default, no lived experience, a hard stop at the training cutoff. The real question isn't "does it know this?" but "how well-represented was this in what it read?"
Characteristic failures: staleness, uneven coverage, inherited bias in what counts as "normal," and no memory of its sources. The 1024-dimension demo shows how retrieval finds meaning, not keywords: "car" lands near "my Civic needs brakes."
Everything the AI attends to lives in a fixed window. Attention weights the edges. What lands in the middle quietly disappears.
It's a cliff, not a gradient: it works until it doesn't, and the overflow is silent. The fix isn't more context, it's smarter: front-load, repeat what matters, start fresh. Memory, compaction and projects push the cliff out.
The model follows instructions the way it does everything: by continuing a pattern. That makes it steerable, and leaves a gap between what you said and what you meant.
When it's followed literally but uselessly, restate the goal; saying it louder won't help. "Shorter, so the exec sees the ask on page two" lands right. In multi-step work, insert a checkpoint so an early slip doesn't carry to the end.
Real-world trouble is rarely one property acting up. Name the two that collided, and the fix points itself out.
Other pairs work the same way: confidently wrong math (offload it to code), an agreeable bad premise (invite genuine pushback). Naming the pair is Discernment applied: you evaluate better when you know what kind of wrong you're looking at.
Fluent use isn't memorising every failure mode. It's recognising which kind of wrong you're looking at, and reaching for the matching response.
That's calibrated trust, and it survives every model upgrade. This course is the machine half; the 4D Framework & Foundations course is the human half that acts on it.
Next Token Prediction, Knowledge, Working Memory, Steerability: locate your task on each, then match how hard you check to where it sits.
tutto.one/praxis · daniel@tutto.one