Lessons

89 lessons are ready.

  1. The same model, five harnesses
  2. The common chassis
  3. Three axes of competition
  4. Harness v0: consent, act, verify
  5. Turn boundaries as a state machine
  6. Event-sourced sessions
  7. Interrupts as first-class events
  8. Survival lab: the Module 1 capstone
  9. The interface is the performance
  10. A tool description is an interface
  11. The wire format is a design decision
  12. Format robustness is a data property
  13. Typed errors as feedback
  14. Doom-loop guards
  15. A tool client from scratch
  16. Code execution as a tool
  17. Progressive disclosure
  18. Placeholders for personal data
  19. Eval-driven tool design
  20. The blast radius lesson
  21. Containers: the cheap, fast default
  22. VMs: sleep, wake, rollback
  23. Sandbox x approval as independent axes
  24. Sandbox lab
  25. The verifier owns done
  26. The two-verifiers lab
  27. In-loop hacking detection
  28. The language-agnostic verifier contract
  29. Reward-hardened graders
  30. Binary pass is a ceiling
  31. Delivery gate lab
  32. The wall
  33. Compaction as a durable transaction
  34. Two-tier compaction and the circuit breaker
  35. Proof-preserving compaction
  36. Cache-prefix discipline
  37. Overflow to disk
  38. Continuity as a filesystem problem
  39. Boss fight: composition under fire
  40. The runaway bill
  41. max_budget as a stop condition
  42. Model routing: cheap models for cheap work
  43. KV-cache locality: the prefix must survive
  44. Fixed-dollar arena: the whole stack, one dollar
  45. The eval that lies
  46. The taxonomy: task, trial, grader, transcript, outcome
  47. Three-mechanism grading: the gate, the rubric, the judge
  48. Grade outcomes, not paths: the exception file
  49. Reward hardening: the bout, and the three moves that end it
  50. Capability to regression graduation
  51. The micro-eval build lab
  52. The merge conflict: one writer at a time
  53. Subagents with depth guards
  54. Orchestrator-workers vs peer teams
  55. Fork semantics: what the child sees
  56. Reviewer amnesia: the fresh context that beats the tired one
  57. Learned orchestration: the policy and the critical path
  58. Crew lab: three roles, three worktrees, one writer
  59. The three-valued gate
  60. Approvals that become policy
  61. The Guardian reviewer
  62. The plan as an editable artifact
  63. Cheap rewind
  64. Engineers in shifts
  65. The session handoff protocol
  66. Todo-list discipline
  67. Sleep/wake and plan gates
  68. Lab: the 3-session build
  69. The continual harness: H=(ρ,G,K,M)
  70. /refine: edit yourself, survive it
  71. Tool synthesis from failure
  72. What self-modification can and can't claim
  73. The falsification kit
  74. Lab: your harness improves itself
  75. RLVR: the gym, not the prompt
  76. Difficulty-aware shaping
  77. Anti-hacking in training
  78. Penalties: unfinished trajectories, bad format
  79. The gym-building agent
  80. Specialize-then-distill vs route
  81. The repo as the system of record
  82. Entropy management: gardening the agent-made mess
  83. Linters that teach
  84. Observability: traces, costs, decisions
  85. Run-close forensics: the postmortem the harness writes about itself
  86. The honesty harness
  87. The long runner
  88. The gym builder
  89. The lean operator