# Learning Path JSON Manifests: The Declarative Backbone of the AI Engineering Curriculum

> Explore Learning Path JSON Manifests the AI engineering curriculum. Discover how model-context-protocol.json and using-coding-agents.json power automated learning and validation in the rohitg00/ai-engineering-from-scratch repo.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: deep-dive
- Published: 2026-08-31

---

**Learning Path JSON Manifests are machine-readable roadmaps that define lesson sequences, prerequisites, and mastery evidence for AI engineering curricula, enabling automated navigation, progress tracking, and validation in the rohitg00/ai-engineering-from-scratch repository.**

Learning Path JSON Manifests serve as the single source of truth for organizing educational content in the `rohitg00/ai-engineering-from-scratch` repository. These declarative files live under the `learning-paths/` directory and declare everything from estimated study time to the specific artefacts learners must produce to prove competency. By consuming these manifests, the curriculum engine auto-generates website navigation, validates lesson integrity, and drives the skill runner without hard-coding path logic.

## What Are Learning Path JSON Manifests?

A **Learning Path JSON Manifest** is a structured JSON file that acts as a master roadmap for a specific curriculum theme. Each manifest follows a consistent schema that allows the curriculum engine to parse prerequisites, lesson ordering, and validation criteria programmatically. The manifests enable a *single-source-of-truth* architecture where content updates automatically propagate to navigation, testing, and deployment pipelines.

### Core Schema Components

Every manifest in the repository shares the same schema structure:

- **schemaVersion**: Guarantees compatibility with curriculum tooling (e.g., `"schemaVersion": 1`).
- **id**, **title**, **summary**: Human-readable identifiers for the learning path.
- **estimatedMinutes**: Total time learners should budget (e.g., `"estimatedMinutes": 1395`).
- **prerequisites**: Required knowledge, software, or prior lessons before starting.
- **invocation**: The CLI command or skill name that launches the path.
- **quickStart**: A minimal "hello-world" command to verify environment setup.
- **publicDeploymentGate**: Optional constraints governing public release of materials.
- **lessons**: Ordered array of required lessons, each specifying `order`, `phase`, `lesson`, `title`, `path`, `minutes`, and **checkpointEvidence**.
- **optionalLessons**: Supplementary, non-required lessons such as capstone projects.

## Inside [`model-context-protocol.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/model-context-protocol.json)

The file [`learning-paths/model-context-protocol.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/learning-paths/model-context-protocol.json) provides the concrete implementation for the Model Context Protocol (MCP) curriculum. This manifest defines 17 mandatory lessons that progress from stateless JSON-RPC fundamentals to advanced security and conformance engineering. The `quickStart` block specifies the command `python3 phases/13-tools-and-protocols/06-mcp-fundamentals/code/main.py`, allowing learners to verify their environment with a single execution.

### Curriculum Engine Integration

The manifest is consumed by three primary systems:

1. **Validation**: [`scripts/audit_lessons.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/audit_lessons.py) parses the JSON, confirms each lesson folder exists at the specified `path`, and verifies that `checkpointEvidence` files are present after lesson execution.
2. **Navigation**: [`site/build.js`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/site/build.js) reads the `lessons` array to auto-generate the website sidebar and progress indicators.
3. **Execution**: The `skills/` directory (e.g., `learn-mcp`) maps the `invocation` block to runnable entry points, enabling learners to start or resume paths via CLI commands.

## The [`using-coding-agents.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/using-coding-agents.json) Manifest Structure

The [`using-coding-agents.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/using-coding-agents.json) manifest follows the identical schema to structure the "Using Coding Agents" curriculum. This parallel definition includes prerequisites such as "Python 3" and the "Tool Interface" lesson, an `invocation` entry like `"codex": "learn-coding-agents"`, and a `lessons` array enumerating topics from "Agent Prompt Engineering" to "Safety Guardrails". Because both manifests share the same schema, the curriculum engine manages any number of learning paths without code changes.

## Working with Learning Path Manifests

Developers interact with these files programmatically to build tooling, validate curricula, or extend the platform.

Load and inspect a manifest using Python:

```python
import json
import pathlib

def load_manifest(name: str) -> dict:
    path = pathlib.Path("learning-paths") / f"{name}.json"
    return json.loads(path.read_text())

manifest = load_manifest("model-context-protocol")
for lesson in manifest["lessons"]:
    print(f"{lesson['order']}. {lesson['title']} ({lesson['minutes']} min)")

```

Execute the quick-start command defined in the manifest:

```bash
python3 phases/13-tools-and-protocols/06-mcp-fundamentals/code/main.py

```

Mirror the schema in TypeScript for frontend tooling:

```typescript
export interface LearningPath {
  schemaVersion: number;
  id: string;
  title: string;
  summary: string;
  estimatedMinutes: number;
  prerequisites: Prerequisite[];
  invocation: Invocation;
  quickStart: QuickStart;
  lessons: Lesson[];
  optionalLessons?: Lesson[];
}

```

## Summary

- **Learning Path JSON Manifests** are declarative configuration files that define curriculum structure, prerequisites, and lesson ordering.
- The manifests reside in `learning-paths/` and follow a strict schema including `schemaVersion`, `checkpointEvidence`, and `invocation` fields.
- [`model-context-protocol.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/model-context-protocol.json) exemplifies a real-world implementation for the MCP curriculum, specifying 17 lessons and a total of 1395 minutes.
- The curriculum engine ([`scripts/audit_lessons.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/audit_lessons.py), [`site/build.js`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/site/build.js), and `skills/`) consumes these manifests to validate content, build navigation, and execute learning paths.
- [`using-coding-agents.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/using-coding-agents.json) demonstrates how the same schema supports multiple curricula without tooling modifications.

## Frequently Asked Questions

### What is the purpose of checkpointEvidence in lesson definitions?

The **checkpointEvidence** field declares the specific artefacts learners must produce to prove lesson completion, such as output files, code commits, or test results. The CI harness checks for these artefacts after lesson execution, enabling automated verification that the learner has mastered the material before proceeding.

### How does the curriculum engine validate manifest integrity?

The [`scripts/audit_lessons.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/audit_lessons.py) script parses each manifest and validates that every lesson `path` points to an existing directory. It aggregates estimated minutes across all lessons and confirms that `checkpointEvidence` specifications are present, ensuring the curriculum remains functional as content evolves.

### Can I create a custom learning path using the existing schema?

Yes. By creating a new JSON file in `learning-paths/` that adheres to the schema—including `schemaVersion`, `id`, `lessons`, and `invocation`—the existing toolchain will automatically recognize, validate, and serve your curriculum without modifying the engine code.

### What is the difference between the invocation and quickStart fields?

The **invocation** field specifies the canonical command or skill name used to launch the full learning path (e.g., `"command": "learn-mcp"`), while **quickStart** provides a minimal one-liner (e.g., running a specific [`main.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/main.py)) that learners execute to verify their environment is configured correctly before starting the full curriculum.