"I taught the loop three times: once as math, once as code, and once when the lab robot ignored both."
A Patient Instructor Controller
Teaching with This Book closes the book by turning advanced embodied AI ideas into artifacts: memory traces, continual-learning panels, frontier claim audits, capstone deliverables, and teaching plans. The chapter offers graduate, advanced undergraduate, two-term, and seminar paths. Each path keeps the book rhythm intact: mechanism, build, shortcut, audit, and reflection.
Teaching embodied AI works best when each week ends in an artifact that makes perception, action, evaluation, and reflection visible. Read the chapter by asking the same four questions on every page: what changes in the loop, what evidence is saved, what can fail, and which tool makes the practical path shorter.
Chapter Overview
Chapter 60 is a deployment guide for instructors. It maps the book into a one-semester graduate course, an advanced undergraduate adaptation, a two-semester sequence, a research seminar, an infrastructure plan, and a grading framework that stays aligned with the book's engineering values.
The chapter treats curriculum design as a systems problem. Weekly pacing, lab architecture, compute budgets, capstone milestones, and rubric weights are all part of the same teaching loop, because course structure determines which embodied-AI habits students actually internalize.
Prerequisites
Readers should be comfortable with Python, tensors, and the perception-action loop. When the chapter uses geometry, control, or probability, the relevant appendices provide a compact refresher.
Chapter Roadmap
- 60.1 One-semester graduate course (14 weeks)Defines a research-oriented weekly rhythm with artifacts, papers, and capstone milestones.
- 60.2 One-semester advanced undergraduate course (lighter theory, more labs)Shows how to reduce formal load without reducing systems depth or debugging honesty.
- 60.3 Two-semester sequenceSplits foundations and advanced topics into a coherent multi-term progression.
- 60.4 Research-seminar trackTurns the frontier chapters into a repeatable paper-audit and replication seminar format.
- 60.5 Lab infrastructure and compute budgeting for instructorsCovers pinned environments, fallback paths, and realistic compute planning.
- 60.6 Assessment, rubrics, and academic-integrity notes for code assignmentsAligns grading, integrity policy, and evidence bundles with actual engineering understanding.
This chapter uses the right-tool principle. Build the mechanism once, then reach for maintained tools such as MuJoCo, MJX, Isaac Lab, Genesis, Newton, Drake, ROS 2, and modern Gazebo when the task moves from learning exercise to working system.
Hands-On Lab: Design a Course Artifact Pipeline
Objective
Choose one teaching format from the chapter and draft the weekly artifact, compute, and grading pipeline needed to run it reliably.
Steps
- Pick a format: graduate course, undergraduate course, seminar, or two-term sequence.
- List three representative weekly artifacts and the infrastructure each one needs.
- Assign one fallback path for a lab that exceeds local hardware or time limits.
- Write a rubric with separate weights for implementation, evidence, and failure analysis.
- Summarize one risk that would break the course if left implicit.
What's Next?
Continue with Section 60.1: One-semester graduate course (14 weeks), where the chapter moves from motivation to the first concrete idea.
This chapter is written for readers who want to teach from the book without inventing a curriculum from scratch. Read each section twice: first as pedagogy, then as an operations plan for weeks, repositories, environments, and grading workflows.
| Tool or Library | Where It Pays Off |
|---|---|
| Jupyter and Colab | Use for low-friction labs, scaffolded assignments, and shareable artifact notebooks. |
| MuJoCo, Isaac Lab, and simulator presets | Use when a course needs repeatable embodied environments without full robot hardware dependence. |
| GitHub Classroom, CI, and grading rubrics | Use for assignment distribution, reproducibility checks, and structured feedback. |
| LeRobot and pinned model checkpoints | Use when students need modern embodied-policy examples without building every stack from zero. |
| Replay exporters and logging dashboards | Use when teaching students to defend evidence rather than only final scores. |
Extend the course-pipeline lab by adding one pinned environment file, one hardware fallback policy, and one oral or written integrity check tied to the artifact bundle.
The chapter can be read by individual instructors, teaching assistants, and program designers. Its main claim is that embodied-AI teaching quality depends on structure: explicit artifacts, realistic lab budgets, stable repository conventions, and rubrics that reward explanation and evidence.
For course design, the practical stack should be introduced as a set of operational choices rather than a shopping list. Every tool should earn its place by shortening setup time, improving reproducibility, or exposing an interface students will actually meet in research and deployment work.
Before leaving the chapter, the reader should be able to state one theory claim, one implementation claim, one evaluation claim, and one realistic failure mode. If any of those four are missing, the chapter should be revisited through the lab.
A strong chapter session ends with an artifact: a small script, a plotted trace, a simulator run, a data card, or a reproducible evaluation panel. The artifact is what turns reading into embodied-system-building practice.
Reader Outcomes And Assessment Pattern
The chapter offers graduate, advanced undergraduate, two-term, and seminar paths while preserving one shared teaching philosophy: every week should leave behind a reproducible artifact, and every artifact should be tied to a reflection or defense step. By the end, the reader should be able to turn the book into a course that is rigorous, modern, and operationally realistic.
| Dimension | What The Reader Produces | Quality Gate |
|---|---|---|
| Mechanism | A concise explanation of the loop component changed by course design. | The explanation names observation, state, action, and feedback. |
| Implementation | A baseline plus a maintained-tool route using Colab notebooks, local simulators, shared logs. | The two routes save the same artifact schema. |
| Evaluation | A same-panel metric comparison with perturbation and failure labels. | Numbers are co-computed in one run on one config. |
| Communication | A short postmortem that distinguishes concept, system, and evidence claims. | The postmortem includes one limitation and one next test. |
Run the chapter as a two-pass build. First, implement the smallest baseline that exposes the mechanism. Second, replace the brittle part with the maintained tool that preserves the same contract. The deliverable is a folder with code, config, logs, plots or traces, and labeled failures.
Bibliography & Further Reading
Foundational Papers, Tools, and References
Sutton, R. S., and Barto, A. G.. "Reinforcement Learning: An Introduction." (2018). http://incompleteideas.net/book/the-book-2nd.html
A foundation for value functions, policy gradients, exploration, and the RL framing used throughout the book.
Todorov, E., Erez, T., and Tassa, Y.. "MuJoCo: A physics engine for model-based control." (2012). https://mujoco.org/
The simulator lineage behind much modern robot learning, now extended through MJX and Warp workflows.
Brohan, A. et al.. "RT-1: Robotics Transformer for real-world control at scale." (2022). https://arxiv.org/abs/2212.06817
A landmark in large-scale robot policy learning with transformer policies.
Brohan, A. et al.. "RT-2: Vision-Language-Action Models Transfer Web Knowledge to Robotic Control." (2023). https://arxiv.org/abs/2307.15818
A central reference for connecting web-scale VLM knowledge to robot actions.
Open X-Embodiment Collaboration. "Open X-Embodiment: Robotic Learning Datasets and RT-X Models." (2023). https://arxiv.org/abs/2310.08864
The cross-embodiment data and transfer reference used by the data chapters.
Chi, C. et al.. "Diffusion Policy: Visuomotor Policy Learning via Action Diffusion." (2023). https://arxiv.org/abs/2303.04137
The practical diffusion policy reference for imitation learning and continuous action generation.
Hafner, D. et al.. "Mastering Diverse Domains through World Models." (2023). https://arxiv.org/abs/2301.04104
DreamerV3, a modern reference for latent world models and imagination-based control.
Hugging Face. "LeRobot." (2024). https://github.com/huggingface/lerobot
The open robot-learning stack used for datasets, policies, demos, and low-cost embodied AI workflows.
Official documentation and source repositories for Teaching with This Book.
Use official docs to check install commands, current APIs, and version caveats before applying Teaching with This Book in a lab or project.