This is the third workshop built on the same machinery as Terminal Velocity and Borrow Native, and the first one where the audience isn’t a practitioner picking up an unfamiliar language. Object Lesson’s learners are new to the subject itself: object-oriented design, not just Java’s syntax. That sounds like a small distinction until you try to write a sentence that assumes zero OOP vocabulary while still respecting that the same learner already drives a coding agent (a harness: Claude Code, Codex, or an equivalent tool) every day for everything except their own education. Mirror image of the last workshop’s audience, not the same shape reused, and it changed almost every design call downstream of it.
The name came first. java-oop-workshop was always a placeholder, and the candidates that survived a real naming pass all tried to say the same thing a different way: this isn’t a vocabulary quiz, it’s judgment exercised against real code. Object Lesson won because it means both things at once, the literal subject and the older idiom for a lesson learned by consequence rather than told to you, without needing a subtitle to explain the pun.
The design brief is where the actual work lives, and it isn’t guesswork dressed up as research. Three real curricula got checked directly rather than recalled from memory: Oracle’s own Java Tutorials, “Objects First with Java” (the BlueJ-paired textbook, now in its seventh edition), and Exercism’s Java track, fetched as data, not summarized secondhand. That direct-fetch discipline caught its own mistake before anyone else did: an early draft of the chapter-numbering section for “Objects First” quietly dropped four chapters from Part Two and shifted everything after them down by four, which meant citing “Handling Errors” as chapter fourteen when it’s actually chapter eighteen. The argument built on top of that citation, that exception handling belongs late in the arc because both cited sources place it after inheritance and abstraction, still holds. The specific number just needed fixing, and it got caught before it shipped anywhere a learner would see it.
Nine modules came out of that research, each stating a real prerequisite instead of assuming a learner read the last one in order: Classes & Objects, Constructors, Encapsulation, Inheritance, Polymorphism, Abstraction, Composition vs. Inheritance, Exception Handling, then a synthesis capstone. Every module carries two gates, not one: a deterministic gate first, javac compiling clean plus JUnit green plus Checkstyle clean, no opinion involved, and then a conceptual pass from Coachgremlin, this workshop’s teaching agent, checking whether the design underneath is actually sound. That second gate matters more here than it did for the Rust workshop before it, and the reason is uncomfortable to say plainly but worth saying anyway: a class with a getter and setter pasted onto every field compiles and passes its tests exactly as cleanly as a class that protects a real invariant. The compiler cannot tell cosmetic encapsulation from the real thing. Only the conceptual gate can, which means this workshop leans on Coachgremlin’s judgment harder than its sibling did, and that judgment is itself unproven at this point, a working hypothesis, not a settled capability.
Running the Workshop Review Panel against that design before writing a line of module content is now standard practice on this machinery, and this run earned its keep again: seven personas, run independently, all seven came back with distinct findings, none purely complimentary. The README rewrite was the cheapest fix and the most obviously needed one: three personas converged from three different angles on the same problem, a “Key Docs” section that linked exclusively to internal governance files and zero learning content, a Quick Start block that was still a literal placeholder comment. That got fixed the same session, along with the chapter-numbering correction above and three places where a hedge was applied inconsistently to structurally similar claims.
Four findings were real design decisions, not text fixes, and got deferred to the deliverables pass rather than rushed: two of the arc’s “hard prerequisite” labels turned out to be editorial preferences wearing a structural label (Encapsulation doesn’t actually require having built a constructor first, and Oracle’s own material teaches interfaces before polymorphism, undercutting the claim that abstraction hard-depends on it), so both got relabeled honestly instead of defended past the evidence. The capstone’s synthesis requirement was asserted, not designed, an empty cross-reference row with no shape to the seeded flaw, so it now has a concrete bar: the fixture has to require three or more of encapsulation, inheritance, and composition jointly, not as independently fixable sub-bugs. And the deterministic gate now carries a design-level commitment it didn’t have before, that javac/JUnit/Checkstyle run inside an isolated sandbox, never on a learner’s bare machine, because this audience is genuinely new to programming in a way the Rust workshop’s wasn’t. None of those four are built yet. They’re decided, which is a different and cheaper thing than built, and the next session’s job is closing that gap.
The module skeleton and brand layer went in on top of all that: all nine module directories, each following the same eight-part README template, and docs/brand.md codifying the voice this very entry is trying to hold, competent peer, not professor, jargon glossed on first use, no claim about what the teaching method achieves stated as settled fact. What you’re reading right now, and the guide page this site’s homepage became, are both downstream of that brand pass, not written before it existed.
What’s actually built: a design, checked against real sources and a real critique, and a skeleton with nowhere to hide a shortcut once content starts landing in it. What’s not built yet: any of it. No exercise, no fixture, no rubric. That’s Coachgremlin’s job, and it hasn’t started.