Tortoise

// Pillar I — Encode

Method

How I run Encode sessions. Sixty minutes, four session-type templates, one bound notebook, and a rule about when to stop drilling and start producing. Versioned and reviewed every 10 learning sessions — the system updates itself when the evidence says so.

// Current version

Next formal evolution at S20

v1.0

Codified 2026-05-04 · session E12

First formal codification. Architecture redesign mid-session after the previous active-loop-per-section pattern produced unsustainable pacing. 4 session-type templates with 60-min cap; physical-techniques layer added; active loop downgraded from default to scalpel.

The four session types

Sessions don't all have the same shape. Watching a lecture is different from writing a script is different from drilling a memory palace. The intake phase classifies which type to run, and the teach phase follows that type's beat template. Sixty minutes total, every type.

VIDEO_VOCAB — lecture-style content

CS50P, Anthropic SDK videos, papers, anything where the goal is consume + extract vocabulary.

  1. Pre-list (~5 min, me): I extract terms + concept skeletons before the watch, with sparse blank-definitions.
  2. Watch (15 min, you): video plays. No live IDE. No live chat.
  3. Handwrite definitions (~10 min, paper + pen): definitions in your own words, in the bound Encode notebook.
  4. Mind map (~5 min, paper): how the terms connect. Center node + spokes + labeled lines.
  5. IDE gotcha test (~5 min): only on the term where pre-test guess revealed wrong model. Skip if all clean.
  6. Memory lesson (~10 min): cold-test prior + encode today's at next No Limits locus, EPIC standard.
  7. Game (~5 min): Phase A foundation rotation.
  8. Close (~5 min): closeout fires.

CODE_BUILD — PSet, scripts, debugging

Hands-on production. The goal is working code, not consumed content.

  1. Spec (~5 min): what does the program need to do? Inputs, outputs, edge cases — written in the notebook before any code.
  2. Code (~40 min, keyboard ONLY): I refuse to write code per project rules. 15-min minimum struggle before concept-level help.
  3. Debug-as-exercise (~5 min): break it on purpose, name the underlying concept.
  4. Mini memory (~5 min): cold test 1 prior lesson. No new encoding on code days.
  5. Close (~5 min).

MEMORY_DEEP — palace work, retest day

Multiple lesson encoding, palace walks, retest-heavy days.

  1. Cold test priors (~10 min): Day-1 / 3 / 7 / 30 retests per spaced-rep schedule. No hints. Honest ★1-5.
  2. Encode new lessons (~30 min): 2-3 new lessons at next No Limits loci. EPIC standard mandatory. Atomic loci protocol.
  3. Palace walk (~5 min): random-order cold walk L1 → Ln. Drift check.
  4. Game (~10 min): comp game from rotation.
  5. Close (~5 min).

MIXED — default for blended days

Compressed version of all four when the day touches multiple tracks.

  1. Video + vocab compressed (~25 min): pre-list → watch → handwrite → IDE gotcha only.
  2. Memory (~15 min): cold test prior + encode 1 new at EPIC.
  3. Code (~15 min, keyboard only): small production task tied to today's vocab.
  4. Game + close (~5 min).

Universal rules

60-minute cap. Every session type. Extend only on explicit request. Closeout fires at the cap unless I say otherwise.

Code = keyboard only. No voice-to-text dictation for syntax. Voice destroys code: it converts = into the word "is", drops closing quotes, drops parentheses, drops the dot in method calls. Voice is for English. Keys are for code.

Paper + pen for definitions, mind maps, Feynman explanations. One bound Encode notebook is the artifact. Over 60+ sessions it compounds into a hand-built textbook + reference + portfolio piece.

The active loop is a scalpel. Predict → IDE → break → Feynman fires only when a pre-test guess revealed a wrong mental model OR word-label drift was caught OR the concept has a known non-obvious gotcha (immutability, mutation, scope) OR it's a foundational concept future work depends on. Otherwise: watch, articulate in one sentence, move on.

Miles drives cadence. When the learner says "lock and move," I lock and move. No drilling past concept-clear signals.

Physical techniques

Encode is not screen-only. The longhand effect (Mueller & Oppenheimer 2014) — handwritten notes outperform typed on retention because the slower pace forces synthesis. Plus dual-coding compounds: visual (paper) + auditory (lecture) + motor (handwriting) builds three traces vs one. Plus anti-screen — gets eyes off keyboard and breaks dictation-corruption pattern.

P1 — Longhand terms + definitions
After watching a video segment or reading a paper, write the key terms and own-words definitions in the notebook. Pre-list comes from me with sparse blanks; you fill in from what you saw.
P2 — Mind maps
Concepts radiating from a central node, lines drawn between connected ideas. One page per topic. Pairs naturally with palace work — palace is items, mind map is relations.
P3 — Code-flow diagrams
Boxes-and-arrows for what code DOES, step by step. Not the syntax — the data flow and control flow. Best for understanding function calls, loops, conditional branching.
P4 — Feynman pad
Dedicated section for two-sentence "explain to a 6-year-old" explanations. One concept per page. If you can't fit it, you don't understand it. Compounds into a self-built textbook over time.

One bound notebook hosts all four. Single bound book — composition book or Moleskine — every session uses it. Chronological progression visible. Browseable in five years to see the arc.

The architectural-pivot rule

When repeated effort fails to produce results, change the technique — not the intensity. Failure is signal.

Repetition strengthens an existing trace. If the trace is wrong — wrong technique, wrong substrate, wrong frame — repetition strengthens the wrongness. The brain doesn't distinguish "more of the right thing" from "more of any thing." Six reps of the wrong frame is six layers of paint on a crooked wall. The wall is still crooked.

Track effort vs result. After 3 reps without progress, stop. Diagnose the substrate (verbal vs concrete vs visual), the frame (vocab vs gotcha vs immutability), the tool. Pivot before pushing. Trial AND error — the error half is data; running the same trial 6 times is friction, not error.

Evolution cadence

The method gets a formal review and version bump every 10 learning sessions. Between formal versions, the page receives small in-place corrections as evidence comes in. At the milestone (S10, S20, S30, …), the past 10 sessions are audited — what produced signal, what was friction, what the data says. The version bumps. The changes are logged. The next 10 sessions test the new version.

This page is the system updating itself in public. The method is the meta-skill of "study-master training," and the discipline of evolving it on a fixed cadence is itself the practice.

Version history

v1.0 · · session E12

First formal codification. Architecture redesign mid-session after the previous active-loop-per-section pattern produced unsustainable pacing. 4 session-type templates with 60-min cap; physical-techniques layer added; active loop downgraded from default to scalpel.

// Changes

  • 4 session-type templates introduced: VIDEO_VOCAB, CODE_BUILD, MEMORY_DEEP, MIXED (plus TOOLING legacy)
  • 60-min cap default for all session types — extend only on explicit request
  • Universal rule: code = keyboard only (voice destroys quotes, converts = to 'is', drops parens — E12 evidence)
  • Universal rule: paper + pen for definitions, mind maps, Feynman explanations; one bound notebook compounds into hand-built textbook
  • Active loop (predict → IDE → break → Feynman) downgraded to SCALPEL — fires only on wrong mental model OR word-label drift OR known gotcha OR foundational concept
  • Architectural-pivot rule discovered: when repeated effort fails 3+ reps, change technique not intensity. Failure is signal.

// Evidence from prior sessions

  • S1-S11: active-loop-per-section produced strong concept-locks but burned 2-3× the planned session length
  • E11-E12: verbal drill of f-string definition failed 6 reps across two sessions; pivoted to REPL contrast and locked in 1 attempt
  • E11: Lesson 1 EPIC encoded ★★★★★ at Day 0; Day-1 cold test at E12 caught drift on I and C pillars (image enrichment hypothesis tentatively NOT supported as Day-1 durability marker)
  • E12: voice-to-text destroyed code repeatedly — = became 'is', closing quotes dropped, lower() typo'd to lowe(); Python 3.14 caught all three with tutor-grade error messages

v1.0 is the first formal codification. Prior sessions S1-S11 ran under an implicit, informal version. The next entry lands at session 20.

Source — the live phase files that run these sessions are in the tortoisehq/Encode repository: CLAUDE.md, phases/encode-intake.md, phases/encode-teach.md, .encode/resources/techniques.md.