Learn by building, with your own agent

Workshops, not tutorials.

Every workshop here is self-paced and gated: a real artifact you build with your own coding-agent harness, checked against a rubric or a deterministic test, no "read this, then move on." Each one is its own repo, its own site, and its own honest build log.

shipped

Terminal Velocity

Learn agentic engineering by running it in a harness, not reading about it.

5 of 5 core exercises real, reviewed, and evidenced

Prompt engineering, context engineering, harness engineering, and loop engineering, taught as one evolving practice instead of four unrelated topics. Every exercise runs through your own coding-agent harness; Coachgremlin frames the task and grades the attempt, never hands you the solution. Built for practitioners already using Claude Code, Codex, or Cursor daily: the only vocabulary assumed unfamiliar is "context engineering" and "loop engineering" themselves.

shipped

Closed Book

Build it with Claude. Prove you don't need Claude to pass.

10 of 10 modules real, doubt-driven-development reviewed, both Foundations and Professional arcs complete

Anthropic's Claude Certified Architect material (Foundations, then Professional), taught the agent-native way. Every module has two parts: build a real artifact hands-on with Claude Code, then close the session and take a timed, closed-book practice checkpoint, no AI, no notes, modeled on the real exam's own blueprint and question style. The tension is the point: learning with the agent doesn't count until you can also defend it without one. Not affiliated with or endorsed by Anthropic; completing it doesn't itself credential anything.

shipped

Copilot Fluent

The first workshop in this series for someone who has never touched a coding agent.

9 of 9 modules real

Nine modules teaching Microsoft 365 Copilot inside one running fictional wealth-management firm, Kellerman & Castle: drafting inside Word/Outlook, verifying AI output against source data instead of trusting it, conversations and memory, working with a Researcher/Analyst agent, and a synthesis capstone, mapped to the AB-730 certification blueprint. No compiler, no test suite, no coding-agent harness underneath it: the gate is a self-attested checklist plus an AI-graded rubric, several modules holding a hidden grading key back until the learner has already committed to an attempt.

building

Borrow Native

Learn Rust the way you already work, with your agent, and let the compiler, not an opinion, be the first gate.

2 of 8 modules real (Ownership & Move Semantics, Borrowing & References)

Ownership, borrowing, structs and enums, generics and traits and lifetimes, error handling, concurrency, and async, taught to people who already drive a coding agent daily. Two checks on every exercise: a deterministic one (cargo test / cargo clippy, no opinion involved) and a conceptual one from Coachgremlin (did you actually work with the borrow checker, or reach for .clone()/unsafe to make it stop complaining?). The name is the pitch: not aiming to get past the borrow checker, aiming to become native to it.

building

Half-Life

Don't take the paper's word for it. Measure your own model's context decay, then prove your fix actually works.

All 6 modules skeleton-only (question, gate shape, and takeaway shape decided; no authored exercise yet)

Why LLMs degrade over long context: positional bias, length-driven context rot, and compaction loss. One real, cited number to start: Chroma's 2025 Context Rot report found accuracy dropped 30+ points when relevant information sat further from the start of context. Taught to people who already work with LLMs daily, through empirical-tier exercises (run the measurement yourself) paired with a conceptual gate. The paper measured someone else's model. This measures yours.

building

Object Lesson

Learn object-oriented design in Java the way you already work, with your agent, and let the compiler and a real test suite, not a quiz, be the first gate.

0 of 9 modules real yet — arc designed, skeleton scaffolded, first module not started

Classes and objects, constructors, encapsulation, inheritance, polymorphism, abstraction, composition versus inheritance, and exception handling, taught to first-year students who already drive a coding agent daily but have never written a class in any language. Two checks on every exercise: a deterministic one (javac, JUnit, Checkstyle, no opinion involved) and a conceptual one from Coachgremlin (is that encapsulation real, or just a getter and setter pasted on because that's what OOP means?). The first workshop in this series built for a genuine subject beginner instead of a practitioner already fluent in everything next door.

building

Heartbeat

Build Raft from scratch in Rust and find out exactly which invariant you got wrong when the simulated network starts lying to you.

3 of 9 modules real (RPC layer, single-node Checkout service, Raft leader election); Modules 04-09 skeleton only

MIT 6.5840's real lab order, translated to Rust: an RPC layer, a single-node service, then Raft itself (leader election, log replication, persistence, log compaction), a fault-tolerant service on top of it, and sharding, ending in a synthesis capstone. Every module is graded twice: a deterministic tier (a turmoil-simulated network actively working against you, not a happy-path test suite) and a conceptual tier from Coachgremlin. The shared throughline project is Checkout, a distributed lock and session-ownership service real enough that this factory's own git worktrees needed one.