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

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

The file 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 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 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 Manifest Structure

The 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:

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:

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

Mirror the schema in TypeScript for frontend tooling:

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 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, site/build.js, and skills/) consumes these manifests to validate content, build navigation, and execute learning paths.
• 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 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) that learners execute to verify their environment is configured correctly before starting the full curriculum.

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