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

> Master the MOTTO to SHIP IT lesson structure, an 11-section template for AI Engineering curriculum. Learn to define core ideas and document reusable artifacts for effective knowledge transfer.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: architecture
- Published: 2026-09-02

---

**The MOTTO to SHIP IT lesson structure is a rigid 11-section template defined in [`LESSON_TEMPLATE.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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)](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](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LESSON_TEMPLATE.md#L28) of the template, the format is:

```markdown
> [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](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LESSON_TEMPLATE.md#L30-L34). 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](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LESSON_TEMPLATE.md#L35-L39)) 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](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LESSON_TEMPLATE.md#L40-L45)) 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](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LESSON_TEMPLATE.md#L46-L64)) requires step-by-step construction using H3 subheadings for each phase:

```markdown

### 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](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LESSON_TEMPLATE.md#L66-L70)) 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](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LESSON_TEMPLATE.md#L72-L77)) 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](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LESSON_TEMPLATE.md#L78-L83) 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](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LESSON_TEMPLATE.md#L84-L89)) 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](https://github.com/rohitg00/ai-engineering-from-stretch/blob/main/LESSON_TEMPLATE.md#L90-L94)) 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](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LESSON_TEMPLATE.md#L96-L133)) 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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/docs/en.md):

```markdown

# 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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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)](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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/docs/en.md). This three-part separation ensures clean organization between narrative content, runnable implementations, and reusable production assets.