# AI Engineering Tutorials and Guides: Complete Hands-On Curriculum

> Explore AI engineering with hands-on tutorials and guides. This complete curriculum offers explanations, runnable code, and deployable artifacts for practical learning.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: tutorial
- Published: 2026-06-06

---

**Yes, the rohitg00/ai-engineering-from-scratch repository contains 503 comprehensive tutorials and guides, each providing a narrative explanation in [`docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/docs/en.md), Python implementations in [`code/python/yolo.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/code/python/yolo.py), and a ready-to-use skill in [`outputs/skill-yolo.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/outputs/skill-yolo.md).

## Navigating the Curriculum Index

The top-level **[`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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:

```text
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:
   ```bash
   cat phases/04-computer-vision/06-object-detection-yolo/docs/en.md
   ```

3. **Run the executable code** using the entry script for your language:
   ```bash
   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:
   ```bash
   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:

```python
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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/install_skills.py)** – One-click installer that makes all tutorial artifacts available to your local agent environment.
- **[`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/docs/en.md)), runnable code (`code/`), and production artifacts (`outputs/`).
- Lessons support multiple languages including **Python**, **TypeScript**, **Rust**, and **Julia**.
- The **[`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md)** serves as the master curriculum index for discovering tutorials.
- Use **[`scripts/install_skills.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/docs/en.md) narratives contain essential context about hyperparameters, expected outputs, and mathematical foundations that help debug issues and understand results.