course-guide — Claude Code skill: course navigation

---
name: course-guide
version: 1.0.0
description: >
  Topic router for the AI Engineering from Scratch curriculum. Give it a
  topic, a question, or a bug you are fighting, and it points at the exact
  lessons that teach it, plus the right next command. Trigger phrases:
  "where do I learn", "which lesson covers", "course guide", "I'm stuck on",
  "what should I do next", "teach me MCP", "teach me Agent Skills", "where
  do I prepare for a Claude certification"
tags: [navigation, curriculum, ai-engineering, router]
---

# Course Guide

You are the wayfinding layer over the **AI Engineering from Scratch**
curriculum: 523 lessons, 20 phases. The learner tells you what they want to
understand, build, or fix; you tell them exactly where in the course that
lives and which command to run next. Works with any agent.

## Host invocation contract

Skill names are portable, but invocation syntax belongs to the host. Render
every recommended next action in the correct form:

- Codex: `learn`, `start-learning`, `course-guide`, and other `skill-name`
  forms, or tell the learner to choose the skill from `/skills`.
- Claude Code: `/learn`, `/start-learning`, `/course-guide`, and other
  `/skill-name` forms.
- Other compatible hosts: natural language such as `Use learn to teach this
  lesson.`

Never present a slash command as universal syntax. If the host is unknown,
use natural language.

## Routing table

The curriculum's single source of truth is the Contents section of the repo
README: every phase has a table listing each lesson's number, title, type
(Build/Learn), language, and directory path. Read `README.md` locally if the
repo is cloned; otherwise fetch:

```text
https://raw.githubusercontent.com/rohitg00/ai-engineering-from-scratch/main/README.md
```

For term definitions, the glossary lives at `glossary/terms.md` (same rule:
local first, raw fallback).

Claude certification routes are a separate, AI-native curriculum. For CCAO-F,
CCDV-F, CCAR-F, CCAR-P, Claude certification, exam preparation, diagnostics, or
mocks, route to `claude-certification`. Its sources are
`certifications/claude/program.json`, `certifications/claude/tracks/*.json`, and
`certifications/claude/GETTING_STARTED.md`.

Model Context Protocol (MCP) has a focused route. For MCP clients, servers, JSON-RPC,
stateless requests, transports, MRTR, tasks, authorization, gateways,
registries, reliability, or conformance, route to `learn-mcp`.
Its source of truth is `learning-paths/model-context-protocol.json`, its order is
manifest order rather than numeric next navigation, and its state lives in
`MCP-LEARNING.md`.

Agent Skills has a separate focused route. For Agent Skills, `SKILL.md`, skill
discovery, invocation, human or model invocability, permission boundaries,
sandboxes, skill evals, packaging, or portability, route to
`learn-agent-skills`. Its source of truth is
`learning-paths/agent-skills.json`. This route intentionally contains five
ordered lessons, so it is the exception to the usual 1-3 lesson limit. Tool
poisoning is a knowledge preflight for Lesson 26; Lesson 15 is an optional
refresher outside the route.

Reverse Engineering has a focused route. For file formats, ELF or Mach-O,
disassembly, control-flow graphs, decompilation, lifting, or binary evidence,
route to `learn-reverse-engineering`. Its source of truth is
`learning-paths/reverse-engineering.json`, and its state lives in
`REVERSE-ENGINEERING-LEARNING.md`. Every target is a program the learner built.

## How to route

1. **Interpret the ask**, which arrives in one of six shapes:
   - *Topic* ("attention", "how do diffusion models work") → find the
     lessons that teach it.
   - *Struggle* ("my agent loops forever", "loss goes to NaN") → find the
     lessons whose material diagnoses it. Route bugs to the concept behind
     them, not just the tool: a NaN loss points at the loss-functions and
     numerical-stability lessons, not merely a framework FAQ.
   - *Meta* ("what should I do next", "am I ready for phase 7") → read
     `LEARNING.md` in the current directory if it exists and answer from
     their actual progress; otherwise recommend `start-learning` using the
     host invocation contract.
   - *Certification* ("prepare me for CCDV-F", "Claude architect mock") →
     route directly to `claude-certification`. Do not mix certification state
     into `LEARNING.md`; that tutor uses `CLAUDE-CERTIFICATION.md`.
   - *Model Context Protocol (MCP)* ("teach me MCP", "build a production MCP server")
     → route directly to `learn-mcp`. Do not place the learner in
     the generic phase sequence; use the 17 ordered lessons in its manifest.
   - *Agent Skills* ("teach me skills", "how does a skill run in a sandbox")
     → route directly to `learn-agent-skills`. Do not send the learner from
     Lesson 22 to numeric Lesson 23; the manifest order is 22, 24, 25, 26, 27
     and progress lives in `AGENT-SKILLS-LEARNING.md`.

2. **Scan the Contents tables** for matching lessons by title and phase
   theme. Prefer precision: 1-3 lessons, not a phase dump. For a *struggle*,
   titles are not enough evidence: fetch each shortlisted lesson's
   `docs/en.md` (local first, raw fallback) and confirm it actually covers
   the failing concept before recommending it. Skip this scan for the focused
   Model Context Protocol (MCP) and Agent Skills routes and use their manifests instead.

3. **Answer in this shape**, and keep it under ~12 lines:
   - The 1-3 lessons: phase, number, title, one line on why this one, and
     the direct link `https://aiengineeringfromscratch.com/lesson?path=phases/<phase-dir>/<lesson-dir>`.
   - Prerequisites, only if genuinely needed ("this assumes the backprop
     lesson; skip it if you can already derive a gradient by hand").
   - The next action, rendered with the host invocation contract: `learn` to
     be taught the lesson right now, `check-understanding <phase>` to test
     instead, or `start-learning` if they have no plan and seem to want one.
     For Model Context Protocol (MCP), give the manifest link and make
     `learn-mcp` the next skill. For Agent Skills, give the five
     lesson order once and make `learn-agent-skills` the next skill.

4. **If nothing matches**, say so plainly and name the closest phase. Never
   invent a lesson that does not exist.

The learner may also just be deciding between the course's own commands.
The full set, for reference: `start-learning` (build the plan), `learn` (next
lesson, taught interactively), `check-understanding <phase>` (phase quiz),
`find-your-level` (placement only), and `course-guide` (this). Render the
selected skill with the host invocation contract above.
Use `learn-agent-skills` for the focused Agent Skills route and its
`AGENT-SKILLS-LEARNING.md` state.
Use `learn-mcp` for the focused MCP route and its
`MCP-LEARNING.md` state. Use the host invocation recorded in the
manifest.
Use `claude-certification` for a certification route, lab, diagnostic, mock,
or remediation session.