Where to Find Structured Learning Paths in the AI Engineering From Scratch Curriculum

The structured learning paths for the AI Engineering From Scratch curriculum are defined as JSON roadmap files located in the learning-paths/ directory of the repository.

The rohitg00/ai-engineering-from-scratch repository organizes its curriculum through machine-readable JSON manifests that define complete skill tracks. These structured learning paths specify prerequisites, lesson sequences, and estimated completion times for each engineering track. All path definitions follow a consistent schema and link to concrete lesson implementations under the phases/ directory.

Locating the Structured Learning Path Definitions

All curriculum roadmaps reside in the learning-paths/ directory at the repository root. Each JSON file represents a distinct skill track with its own prerequisites and ordered lessons.

The repository currently maintains the following structured learning paths:

• learning-paths/agent-skills.json — Defines the Agent Skills Engineering track, including prerequisites and lesson sequences such as "22-skills-and-agent-sdks" and "24-skill-discovery-and-progressive-disclosure"
• learning-paths/model-context-protocol.json — Describes the Model Context Protocol (MCP) track, organized into core, bidirectional, secure, and advanced lesson groups
• learning-paths/ — The container directory for all learning path manifests, with additional tracks added as the curriculum expands

JSON Schema and Path Structure

Each learning path file follows a standardized schema containing metadata fields and lesson arrays. According to the source code, the schema includes: schemaVersion, id, title, summary, estimatedMinutes, prerequisites, lessons, and optionalLessons.

Every lesson entry within the lessons array points to a concrete implementation folder under phases/. For example, a lesson with path phases/13-tools-and-protocols/22-skills-and-agent-sdks contains the lesson documentation, code examples, tests, and quizzes.

The directory structure follows this pattern:

phases/
└── 13-tools-and-protocols/
    └── 22-skills-and-agent-sdks/
        ├── docs/
        │   └── en.md          # Human-readable lesson content

        ├── code/
        │   └── main.*         # Runnable implementation

        └── tests/             # Validation tests

Programmatic Access to Learning Paths

You can consume these structured learning paths programmatically to build custom study plans or validate curriculum completion.

Reading a Specific Track with Python

Use the following Python script to fetch and parse the Agent Skills learning path directly from the repository:

import json, pathlib, urllib.request

# Load the Agent Skills learning path from the repository

url = "https://raw.githubusercontent.com/rohitg00/ai-engineering-from-scratch/main/learning-paths/agent-skills.json"
data = json.loads(urllib.request.urlopen(url).read().decode())
print(f"Track: {data['title']}")
print("Lessons:")
for lesson in data["lessons"]:
    print(f"  • {lesson['order']}: {lesson['title']} ({lesson['path']})")

Iterating Over All Available Paths

To list all available learning tracks locally, use this bash command with jq:

# List all JSON manifests in the learning-paths folder

for f in learning-paths/*.json; do
    echo "=== $f ==="
    jq '.title, .lessons[].title' "$f"
done

Key Files in the Curriculum Structure

Understanding the relationship between path definitions and content helps navigate the curriculum efficiently:

File	Role
learning-paths/agent-skills.json	Master definition for the Agent Skills Engineering learning route
learning-paths/model-context-protocol.json	Master definition for the Model Context Protocol (MCP) learning route
phases/…/docs/en.md	Human-readable lesson content referenced by each path entry
phases/…/code/main.*	Runnable implementation files for hands-on practice
phases/…/tests/	Unit tests that validate lesson code correctness
README.md & ROADMAP.md	High-level overview documents linking phases and lessons

Summary

• Structured learning paths are stored as JSON files in the learning-paths/ directory of rohitg00/ai-engineering-from-scratch
• The curriculum currently includes Agent Skills Engineering and Model Context Protocol tracks, defined in agent-skills.json and model-context-protocol.json
• Each JSON file follows a consistent schema with fields for prerequisites, estimatedMinutes, and ordered lessons arrays
• Lesson entries link to concrete folders under phases/ containing documentation, code, and tests
• You can programmatically access these paths using standard HTTP requests and JSON parsers

Frequently Asked Questions

What file format are the structured learning paths stored in?

The structured learning paths are stored as JSON files with a specific schema that includes fields like schemaVersion, id, title, summary, estimatedMinutes, prerequisites, lessons, and optionalLessons. This machine-readable format allows for programmatic curriculum navigation and custom tooling integration.

How do I navigate from a learning path definition to the actual lesson content?

Each lesson object in the JSON arrays contains a path property that maps to a directory under phases/. For example, if a lesson specifies "path": "phases/13-tools-and-protocols/22-skills-and-agent-sdks", the actual content resides in that folder with docs/en.md for theory, code/ for implementations, and tests/ for validation.

Which learning tracks are currently available in the repository?

As of the latest commit, the repository includes two primary structured learning paths: the Agent Skills Engineering track (defined in learning-paths/agent-skills.json) and the Model Context Protocol (MCP) track (defined in learning-paths/model-context-protocol.json). The learning-paths/ directory serves as the container for all current and future curriculum tracks.

How are prerequisites handled in the curriculum structure?

Each learning path JSON file includes a prerequisites field at the track level, and individual lessons follow a sequential order defined by the order property in the lessons array. The schema supports optionalLessons for supplementary content that does not block progression through the core curriculum.

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