AI Engineering Tutorials and Guides: Complete Hands-On Curriculum

Yes, the rohitg00/ai-engineering-from-scratch repository contains 503 comprehensive tutorials and guides, each providing a narrative explanation in docs/en.md, runnable code in code/, and deployable artifacts in outputs/.

The repository is structured as a complete educational curriculum where every lesson functions as a self-contained tutorial covering AI engineering from first principles. These tutorials and guides are organized into 20 phases that progress from foundational theory to production deployment, with each guide combining theoretical explanations with executable implementations in Python, TypeScript, Rust, or Julia.

How Tutorials Are Structured

Each lesson in the repository follows a consistent three-part architecture designed for hands-on learning. The standard directory layout lives under phases/<phase-id>-<phase-name>/<lesson-id>-<lesson-name>/ and contains:

• docs/en.md – The core tutorial narrative that explains algorithms, provides mathematical equations, diagrams, and step-by-step conceptual guidance.
• code/ – Self-contained, runnable implementations that you can execute locally to see concepts in action.
• outputs/ – Generated prompts, skills, agent packs, or MCP servers that represent the ship-ready artifact from the lesson.

For example, the Object Detection with YOLO tutorial occupies phases/04-computer-vision/06-object-detection-yolo/ and contains the narrative in docs/en.md, Python implementations in code/python/yolo.py, and a ready-to-use skill in outputs/skill-yolo.md.

Navigating the Curriculum Index

The top-level README.md serves as the master index for all tutorials and guides. It lists all 20 phases, 503 lessons, and illustrates the "learn → build → use → ship" workflow for the curriculum.

To locate a specific guide, navigate the phases/ directory using the numbering convention:

phases/
├── 01-foundations/
├── 02-neural-networks/
├── 03-natural-language-processing/
├── 04-computer-vision/
│   └── 06-object-detection-yolo/
│       ├── code/
│       ├── docs/
│       │   └── en.md
│       └── outputs/

Each lesson folder name includes its ID and a descriptive slug, making it easy to identify the tutorial content before opening the files.

Running a Tutorial Step-by-Step

Follow this workflow to execute any tutorial in the repository:

1. Select a lesson from the README index, such as Phase 4, Lesson 06 (Object Detection – YOLO).

2. Read the narrative by opening the documentation file:

   cat phases/04-computer-vision/06-object-detection-yolo/docs/en.md

3. Run the executable code using the entry script for your language:

   python phases/04-computer-vision/06-object-detection-yolo/code/python/yolo.py

   This specific command trains a tiny YOLO model on a synthetic dataset and prints the final mAP score.

4. Install the generated artifacts system-wide using the helper script:

   python scripts/install_skills.py

   This command copies all outputs/*.md files into your environment directory where agents can import them.

Automating Tutorial Execution

You can programmatically discover and run lessons using the repository's consistent naming conventions. This Python script locates the first Python file in any lesson directory and executes it:

import subprocess
from pathlib import Path

def run_lesson(phase: int, lesson: int, name: str):
    """Run the main Python file of a lesson."""
    root = Path("phases")
    lesson_path = root / f"{phase:02d}-{name}" / f"{lesson:02d}-{name}" / "code"
    # Find the first .py file (convention: main implementation)

    py_files = list(lesson_path.rglob("*.py"))
    if not py_files:
        raise FileNotFoundError("No Python file found in the lesson.")
    entry = py_files[0]
    subprocess.run(["python", str(entry)], check=True)

# Example: run the YOLO object-detection tutorial (Phase 4, Lesson 06)

run_lesson(4, 6, "object-detection-yolo")

Key Tutorial Files and Resources

Locate these critical files to navigate the tutorial ecosystem effectively:

• README.md – The curriculum index mapping all 20 phases and 503 lessons with quick-start commands.
• phases/*/docs/en.md – The core tutorial text for any given lesson containing explanations and mathematical foundations.
• phases/*/code/* – Minimal, self-contained implementations that execute without external dependencies beyond the specific language runtime.
• phases/*/outputs/* – Ship-ready prompts, skills, and MCP servers generated by completing the tutorial exercises.
• scripts/install_skills.py – One-click installer that makes all tutorial artifacts available to your local agent environment.
• AGENTS.md – Contribution guidelines for extending the tutorials with new lessons or agent implementations.

Summary

• The repository contains 503 hands-on tutorials across 20 phases covering complete AI engineering workflows.
• Each tutorial provides three components: narrative documentation (docs/en.md), runnable code (code/), and production artifacts (outputs/).
• Lessons support multiple languages including Python, TypeScript, Rust, and Julia.
• The README.md serves as the master curriculum index for discovering tutorials.
• Use scripts/install_skills.py to deploy lesson outputs into your working environment.

Frequently Asked Questions

How many tutorials and guides are included in the repository?

The repository contains 503 lessons organized into 20 phases, covering topics from foundational mathematics to advanced agent architectures. Each lesson functions as a standalone tutorial with its own documentation and executable examples.

What programming languages are supported in the tutorial code?

The tutorials provide runnable implementations in Python, TypeScript, Rust, and Julia. The code/ directory within each lesson may contain subdirectories for each language, allowing you to learn concepts in your preferred runtime environment.

How do I install the skills generated by a tutorial?

Run the command python scripts/install_skills.py from the repository root. This script automatically discovers all outputs/*.md files across the phases/ directory and copies them to your system environment where agents can import and use them as modular capabilities.

Can I run the tutorial code without reading the documentation?

Yes, the code in phases/*/code/ directories is self-contained and executable independently. However, the docs/en.md narratives contain essential context about hyperparameters, expected outputs, and mathematical foundations that help debug issues and understand results.

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