This guide explains how to generate individual lesson content for the Physical AI and Humanoid Robotics textbook using AI assistance.
The textbook structure is now complete with:
- 7 Parts covering foundations through capstone
- 22 Chapters organized by topic
- 87+ Lessons (currently placeholders with "Coming Soon" notices)
- 5 Appendices for reference materials
Your task is to generate high-quality, engaging lesson content one lesson at a time.
Navigate to the textbook structure and select a lesson placeholder to develop. Each lesson file contains:
- Frontmatter (sidebar_position, title, description)
- Learning objectives placeholder
- "Coming Soon" notice
- Basic structure
Example paths:
docs/part-02-ros2-ecosystem/chapter-03-ros2-architecture/01-ros1-to-ros2-evolution.md
docs/part-04-nvidia-isaac-platform/chapter-10-isaac-sim/01-isaac-sim-overview.md
docs/part-05-humanoid-development/chapter-14-balance-stability/01-center-of-mass.md
Copy and customize this prompt template for your chosen lesson:
Generate comprehensive content for the following lesson in the Physical AI and Humanoid Robotics textbook:
**Lesson Path**: [e.g., docs/part-02-ros2-ecosystem/chapter-03-ros2-architecture/01-ros1-to-ros2-evolution.md]
**Lesson Title**: [e.g., "ROS 1 to ROS 2 Evolution"]
**Chapter Context**: [e.g., "Chapter 3: ROS 2 Architecture - covering the transition from ROS 1, DDS middleware, packages, and build systems"]
**Part Context**: [Read docs/part-0X-[name]/index.md - the Part overview provides learning goals, connections to other parts, and overall narrative]
**Chapter Context (Detailed)**: [Read docs/part-0X-[name]/chapter-XX-[name]/index.md - the chapter overview lists all lessons and their relationships]
**Content Flow Requirements** (CRITICAL - maintain whole-book coherence):
**Previous Lesson Summary**: [If not first lesson in chapter]
- Provide 2-3 sentence recap of previous lesson's key concepts
- Example: "In the previous lesson, we explored ROS 1's architecture with master-based communication. We learned about roscore, topics, and services, but identified limitations in real-time performance and security."
**Next Lesson Preview**: [If not last lesson in chapter]
- Provide 1-2 sentence preview of what comes next
- Example: "In the next lesson, we'll dive into DDS middleware—the backbone that solves ROS 1's limitations with real-time, distributed communication."
**Cross-Lesson References**:
- Reference concepts from previous lessons explicitly (e.g., "As we learned in Lesson X...")
- Set up concepts for future lessons (e.g., "This will become important when we explore...")
- Maintain narrative thread across the entire book (not isolated lessons)
**Content Requirements**:
1. **Word Count**: 2000-2500 words (comprehensive but engaging)
2. **Structure**: Follow the 8-section lesson template:
- Learning Objectives (4-5 measurable outcomes)
- Introduction (hook + context)
- Main Content (3-5 major sections with subsections)
- Hands-On Practice (2 exercises)
- Key Takeaways (6 bullet points)
- Review Questions (4 questions with collapsible answers)
- Further Reading (4 curated resources)
- What's Next (transition to next lesson)
3. **Interactive Elements** (make it engaging, not boring):
- 5-7 admonitions (:::tip, :::warning, :::note, :::danger, :::info)
- 1-2 Mermaid diagrams for concept visualization
- 3-5 collapsible <details> sections for solutions/answers
- 1-2 comparison tables
- 1 styled callout box for case studies (if applicable)
4. **Code Examples** (2-4 required):
- Use Python with type hints and extensive inline comments
- Show progression from simple to complex
- Include error handling and real-world considerations
- Contextualize for robotics/ROS 2
5. **Pedagogical Approach**:
- Start with a thought experiment or real-world hook
- Build concepts progressively
- Include "Why this matters" explanations
- Connect to broader Physical AI context
- Provide hands-on exercises with guided solutions
6. **Technical Rigor**:
- Include mathematical formulations where appropriate (with intuitive explanations)
- Reference research papers or official documentation
- Show engineering trade-offs and design decisions
- Provide concrete examples (specifications, benchmarks, real systems)
7. **Content Flow and Coherence** (ESSENTIAL):
- **Opening**: Reference previous lesson concepts naturally in Introduction section
- **Body**: Build on previously established knowledge (don't repeat, extend)
- **Closing**: In "What's Next" section, explicitly preview next lesson's focus
- **Cross-References**: Link to related lessons in other chapters/parts when relevant
- **Progressive Complexity**: Assume knowledge from earlier lessons (don't start from zero each time)
- **Narrative Thread**: Maintain story arc across chapter (beginning → middle → end)
8. **Style Guidelines**:
- Write for graduation-level technical depth
- Keep sections digestible (300-400 words per subsection)
- Use active voice and direct language
- Include real-world examples (companies, products, research)
- Balance theory with practice
9. **Before You Generate - Preparation Checklist**:
- [ ] Read the Part overview (docs/part-0X-[name]/index.md) for context
- [ ] Read the Chapter overview (docs/part-0X-[name]/chapter-XX-[name]/index.md)
- [ ] If not first lesson: Read the previous lesson to understand what students already know
- [ ] If not last lesson: Skim the next lesson title to know where you're heading
- [ ] Identify 2-3 concepts from previous lessons to reference
- [ ] Identify 1-2 concepts to set up for future lessons
**Reference Materials**:
[Provide any specific sources, papers, or documentation relevant to this lesson]
**Output Format**:
Provide the complete Markdown content ready to replace the placeholder lesson file, including frontmatter.
After generation, verify the content meets requirements:
- Word count: 2000-2500 words (use word counter)
- Structure: All 8 sections present
- Interactive elements: 5+ admonitions, 1+ Mermaid diagram, 3+ collapsible sections
- Code examples: 2-4 Python code blocks with comments
- Learning objectives: 4-5 measurable outcomes
- Exercises: 2 hands-on activities with solutions
- Review questions: 4 questions with detailed answers
- Further reading: 4 curated resources with URLs
- Frontmatter: Correct sidebar_position, title, description ≤160 chars
- Navigation: "What's Next" links to correct next lesson
- Technical accuracy: Claims verified, code runnable
- Engagement: Thought experiments, real-world examples, varied formatting
- Content Flow (NEW):
- Introduction references previous lesson concepts (if not first lesson)
- Body builds on previously established knowledge
- "What's Next" section previews next lesson (if not last lesson)
- Cross-references to related lessons where appropriate
- Progressive complexity (doesn't restart from basics)
- Maintains chapter narrative arc
Run validation scripts to ensure quality:
# Validate single lesson
python scripts/validate_lesson.py docs/[part]/[chapter]/[lesson].md
# Validate entire chapter
python scripts/validate_part.py docs/[part]/[chapter]/
# Build test
npm run buildAfter validation passes:
- Replace the placeholder lesson file with generated content
- Commit changes with clear message:
feat: Add lesson [title] - Update tasks.md to mark lesson complete:
- [X] T0XX ... - Test in local Docusaurus server:
npm start
Lesson: "Zero Moment Point" (Part 5, Chapter 14)
Key Features:
- Mathematical derivation of ZMP formula
- Mermaid diagram showing force/moment balance
- Python code for ZMP calculation
- Comparison table: ZMP vs COP vs COM
- Real-world example: Boston Dynamics Atlas
Lesson: "Publishers and Subscribers" (Part 2, Chapter 4)
Key Features:
- Progressive code examples (minimal → full node)
- ROS 2 Python template with type hints
- Exercise: Build a sensor publisher
- Debugging tips in admonitions
- QoS policy comparison table
Lesson: "Embodied Intelligence" (Part 1, Chapter 1)
Key Features:
- Philosophical thought experiments
- Perception-action loop diagram
- Case study: Symbol grounding problem
- Comparison: Embodied vs disembodied AI
- Research paper references
Track your lesson generation progress:
- Chapter 1, Lesson 1: From Digital to Physical AI
- Chapter 1, Lesson 2: The Robotics Revolution
- Chapter 1, Lesson 3: Embodied Intelligence
- Chapter 1, Lesson 4: Applications
- Chapter 1, Lesson 5: Learning Path Overview
- Chapter 2, Lesson 1: Machine Learning Basics
- Chapter 2, Lesson 2: Neural Networks Refresher
- Chapter 2, Lesson 3: Computer Vision Fundamentals
- Chapter 2, Lesson 4: NLP Basics
- Chapter 2, Lesson 5: Reinforcement Learning Intro
(Continue for Parts 2-7...)
Generate related lessons in sequence to maintain context:
- All ROS 2 architecture lessons
- All inverse kinematics lessons
- All Isaac Sim lessons
Look at the complete lesson example:
docs/part-01-foundations/chapter-01-introduction-to-physical-ai/01-digital-to-physical.md
This shows ideal structure, interactive elements, and quality level.
Before generating, gather:
- Official documentation links
- Relevant research papers
- Code examples from GitHub
- Real-world use cases
If first generation doesn't meet quality bar:
- Request more interactive elements
- Ask for deeper technical detail
- Request real-world examples
- Add more code examples
Keep similar structure across lessons:
- Same admonition types for similar purposes
- Consistent code style (type hints, comments)
- Similar exercise formats
- Uniform Further Reading sections
- tasks.md: Complete lesson breakdown with descriptions
- spec.md: Quality criteria and success metrics
- plan.md: Implementation strategy and timelines
- templates/lesson-template.md: Full 8-section structure
- docs/part-01-foundations/.../01-digital-to-physical.md: Complete example
- scripts/validate_lesson.py: Automated quality checks
- scripts/validate_part.py: Chapter-level validation
- scripts/validate_textbook.py: Full textbook validation
Recommended Pace: 1 lesson per week
At this pace:
- Part 1 (10 lessons): ~2.5 months
- Part 2 (17 lessons): ~4 months
- Parts 3-7 (60 lessons): ~15 months
- Total: ~22 months for complete textbook
Accelerated Option: 2-3 lessons per week
- Total: ~8-10 months for complete textbook
Generate your next lesson now:
- Choose a lesson from
tasks.md(T014 onwards) - Copy the "Lesson Generation Prompt" template above
- Fill in lesson-specific details
- Paste into your AI assistant (Claude, GPT-4, Gemini)
- Review and validate generated content
- Replace placeholder file
- Test with
npm start - Mark complete in
tasks.md
Example for next lesson:
Generate comprehensive content for:
**Lesson Path**: docs/part-01-foundations/chapter-01-introduction-to-physical-ai/02-robotics-revolution.md
**Lesson Title**: "The Robotics Revolution: Players & Technologies"
**Chapter Context**: Chapter 1: Introduction to Physical AI - establishing foundations
[... rest of prompt template ...]
- Check existing complete lesson for reference
- Run validation scripts to catch issues
- Review spec.md for quality criteria
- Consult plan.md for implementation guidance
Remember: Quality over speed. Each lesson is a building block for the entire curriculum. Take time to make it engaging, accurate, and valuable for learners.
Happy lesson generation! 🚀