I built the tutor, then let it grade me.

He repeatedly imports software-engineering structure onto new mechanism and it fits: he derived “single responsibility per prompt” from the attention cost tradeoff on his own, accepted “training compiles the corpus into the weights, like a stripped binary” instantly, and reads Python through a Swift lens (reference vs value semantics) without being told to. He reasons in systems, not facts — his biggest asset.

His clearest signature, now confirmed across two domains and a cold-review battery: hand him the one missing primitive and he derives the consequence. Given the causal mask, he nailed cold why a bidirectional model can't KV-cache; given “BPE = greedy merge of the most-frequent pair,” he derived the whole multilingual cost story cold — Kannada wins no merges, falls back to byte-level, ~3 tokens/char. The flip side is just as reliable: when he's loose, naming the gap is most of the fix. He's far weaker at inventing primitives from nothing — as he put it, Socratic questioning with no foundation is “just guessing.”

Asked to fix a confident wrong citation, he reached grounding/RAG and explained why it works — attention at the answer position pulls the in-context tokens in and collapses a flat content-token distribution onto the true value — recognizing it as the same mechanism as pasting a fact in. Connecting three concepts into one is exactly the move that makes the platform/RAG path his.

Twice this session he scoped concepts out on his own: he ruled the RoPE rotation→relative-position derivation and the residual-stream's gradient-flow backward pass as too deep for a serving/eval target, keeping the applied conclusion each time (relative position is the lever behind context-extension; the residual add is the interpretability hook). Both cuts were correct, and both for the same reason — cut the training-internals math, keep the serving/eval/interp mechanism. This is the inverse of the completion-seeking I'd watch for in most learners. The thing to watch is only that it stays a judgment, not a reflex for skipping hard things.

He flags his own guesses (“Hmm, I am not sure”) and states partial answers without padding them, which makes him easy to teach honestly — the uncertainty is visible.

Twice early on he reached for the training corpus as if present at runtime — the single most load-bearing idea for his RAG/platform path. Dead since a cold closure check; a later cold walkthrough killed both old autoregressive misconceptions unprompted (“the corpus does nothing at inference; knowledge is in the frozen weights”).

When pressed on a precise gap he used to fall back to a vaguer true-but-weaker claim — “I just meant it increases,” and most recently “EAFP is just less rigid / more flexible.” The last read flagged the EAFP instance as the open thread to close next; it closed. Pushed, he derived both real mechanisms cold — TOCTOU (“check and use are two decoupled ops, the world changes in the gap”) and duck-typing — and unified them himself: “isinstance is hardcoded, len holds for any type with a length.” He can now justify it, not just implement it.

The surviving form of the old reflex, and it still fires: on the first pass he reaches for something true but not quite load-bearing — “K·Q equals Q·K is why” attention is permutation-equivariant (the matrix isn't even symmetric), “longer tokens” when he means more tokens, quadratic compute vs. a quadratic bill. What's changed is the recovery is now automatic: every one of these closed the moment it was challenged, in the same exchange. The work left isn't the recovery — it's tightening the first pass under load.

The quiet residue of the old relapse — he still occasionally phrases enrichment as happening to the “weights” when it's the residual-stream vectors that change (weights are frozen). It didn't slip this session — he gave `x + f(x)` cleanly and unprompted — but it's the thinnest surviving thread and worth one clean cold pass to retire.

Openers that hand him a failure to diagnose (“count the r's in strawberry,” “same prompt, two answers,” “this list is shared across calls — why?”) land far better than “here is concept X.”

The highest-leverage move with him, now confirmed across mechanism, Python, and cold review. When a fact isn't derivable, hand it over and probe what follows — that's where he's strongest, and it's why the spaced-review battery held: the primitives were already his to rebuild from.

Softmax-with-temperature tables, `1000²` vs `10×100²`, `70B × bytes`, ~3 tokens/char for Kannada — every numeric anchor stuck, and the Akshara cost framing made the tokenization review land.

He prefers being challenged over agreed with, and engagement spikes when the mechanism connects to cost, serving, or eval — his actual target work.