MOTTO to SHIP IT Lesson Structure: The Complete Template for AI Engineering Curriculum

The MOTTO to SHIP IT lesson structure is a rigid 11-section template defined in LESSON_TEMPLATE.md that mandates every lesson open with a one-line core idea (MOTTO) and conclude with a Ship It section documenting reusable artifacts stored in the outputs/ folder.

The rohitg00/ai-engineering-from-scratch repository enforces this standardized pedagogical framework to ensure every lesson follows a consistent narrative arc—from conceptual hook to production-ready artifact. By mandating specific headings and content order, the template guarantees that learners encounter predictable patterns while building AI engineering skills, from prompts and agents to MCP servers.

The MOTTO to SHIP IT Framework

The entire lesson specification lives at the repository root in [LESSON_TEMPLATE.md](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LESSON_TEMPLATE.md). This file dictates the exact sequence of sections, metadata formats, and file organization rules that every lesson must follow. The structure progresses from abstract motivation to concrete implementation, ensuring learners understand both the why and the how before producing deployable artifacts.

MOTTO (The Hook)

Every lesson must begin with a MOTTO immediately following the H1 title. This is a single-line blockquote containing the core idea that sticks with the learner. According to Line 28 of the template, the format is:

> [One‑line motto — the core idea that sticks]

This quote serves as the lesson's conceptual anchor, summarizing the fundamental principle before diving into technical details.

Metadata Block

Directly after the MOTTO, lessons must include a standardized metadata block spanning Lines 30-34. This includes:

• Type: The lesson category (e.g., Concept, Implementation, Integration)
• Languages: Programming languages used (e.g., Python, TypeScript)
• Prerequisites: Required prior knowledge or completed lessons
• Time: Estimated completion duration

The Problem

The first narrative section (Lines 35-39) describes the pain point or challenge the lesson addresses. This establishes context and explains why the concept matters in real-world AI engineering scenarios, creating motivation before introducing solutions.

The Concept

Before writing code, lessons must provide a conceptual explanation (Lines 40-45) that builds intuition through diagrams, analogies, or architectural overviews. This section contains no code—it focuses entirely on mental models and theoretical foundations.

Build It

The implementation phase (Lines 46-64) requires step-by-step construction using H3 subheadings for each phase:

### Step 1: Setup Environment

[Explanation]

### Step 2: Implement Core Logic

[Explanation with code block]

Each step combines narrative explanation with runnable code blocks stored in the lesson's code/ directory. The template mandates that code files run without errors and contain no comments (which belong in the documentation instead).

Use It

Following the manual implementation, the Use It section (Lines 66-70) demonstrates how existing frameworks or libraries solve the same problem. This comparison validates the learner's understanding by showing parallels between hand-built solutions and production tools.

Ship It

The SHIP IT section (Lines 72-77) represents the lesson's deliverable phase. Here, authors describe the reusable artifact produced—whether a prompt, skill, agent, MCP server, or tool. This section explicitly links to files placed under the outputs/ folder, which must include:

• Prompts: YAML-style front-matter followed by the prompt template
• Skills: Self-contained functions with type hints and tests

Exercises

To reinforce learning, Lines 78-83 require a 3-point list of tasks categorized by difficulty:

1. Easy: Basic comprehension check
2. Medium: Practical application
3. Hard: Extension or optimization challenge

Key Terms

The glossary section (Lines 84-89) presents a table mapping technical terms to common misconceptions and correct definitions, ensuring learners grasp precise vocabulary.

Further Reading

External resources appear as a bullet list (Lines 90-94) with brief rationales explaining why each link matters to the lesson's context.

Code and Output Guidelines

The template concludes with formatting rules (Lines 96-133) specifying:

• Code files: Must run without errors, include no comments, and reside in code/
• Output files: Must follow specific templates for prompts (YAML front-matter) and skills (executable code with tests)

Practical Implementation Example

When applied to a lesson like "QuickSort Implementation," the MOTTO to SHIP IT structure appears as follows in docs/en.md:

# QuickSort Implementation

> "Sort fast, sort in‑place – the classic divide‑and‑conquer algorithm."

**Type:** Algorithm Implementation  
**Languages:** Python  
**Prerequisites:** Basic recursion, Array manipulation  
**Time:** 45 minutes

## The Problem

Sorting remains fundamental to data processing, yet naive implementations...

## The Concept

Divide-and-conquer splits the problem into smaller sub-problems...

## Build It

### Step 1: Partition Logic

[Implementation details]

### Step 2: Recursive Sort

[Code implementation]

## Use It

Python's built-in `sorted()` uses Timsort, which differs from QuickSort in...

## Ship It

**Prompt** – `quick_sort_prompt.md`  
A reusable prompt that asks an LLM to generate a quicksort implementation in any language.

**Skill** – `quick_sort_skill.md`  
A self‑contained skill that exposes a `quick_sort(arr)` function with full type hints and tests.

File Organization and Conventions

The MOTTO to SHIP IT structure dictates specific directory layouts:

Path	Purpose
LESSON_TEMPLATE.md	Master specification at repository root
phases/*/*/docs/en.md	Lesson documentation following the template
phases/*/*/code/	Implementation files referenced in Build It
phases/*/*/outputs/	Artifacts documented in Ship It (prompts, skills, agents)

According to the source code, the outputs/ directory is non-negotiable—every lesson must produce at least one reusable artifact stored here to satisfy the Ship It requirement.

Summary

• The MOTTO to SHIP IT structure is codified in LESSON_TEMPLATE.md and mandates an 11-section sequence for every lesson.
• Lessons must begin with a one-line MOTTO blockquote and end with a Ship It section describing artifacts in outputs/.
• The narrative progresses through Problem → Concept → Build It → Use It, ensuring learners understand theory before comparing with existing frameworks.
• Build It sections use H3 step subheadings with runnable code blocks, while Ship It documents reusable prompts, skills, or tools.
• Metadata blocks, exercises (easy/medium/hard), key terms tables, and further reading lists are required components, not optional additions.

Frequently Asked Questions

Where is the MOTTO to SHIP IT template defined?

The template is formally specified in [LESSON_TEMPLATE.md](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LESSON_TEMPLATE.md) at the root of the rohitg00/ai-engineering-from-scratch repository. This file provides line-by-line specifications for every required heading and section, from the initial MOTTO blockquote (Line 28) through the Output File Format specifications (Lines 105-133).

What types of artifacts belong in the Ship It section?

The Ship It section documents reusable components placed in the outputs/ folder. Valid artifact types include prompts (LLM instructions with YAML front-matter), skills (typed functions with tests), agents (autonomous task performers), MCP servers (Model Context Protocol implementations), and tools (utility scripts). Each artifact must be production-ready and importable by subsequent lessons.

How does the Build It section differ from the Use It section?

Build It contains the hands-on implementation where learners construct the solution step-by-step using H3 subheadings (e.g., ### Step 1: Environment Setup) and code blocks stored in the code/ directory. Use It follows this with demonstrations of how existing frameworks solve the identical problem, enabling learners to compare their hand-built solution against optimized library implementations.

Where should completed lesson artifacts be stored?

All artifacts referenced in the Ship It section must be stored in the lesson's outputs/ directory, while implementation code supporting the Build It section resides in code/. Documentation following the MOTTO to SHIP IT structure lives in docs/en.md. This three-part separation ensures clean organization between narrative content, runnable implementations, and reusable production assets.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}