AI Engineering From Scratch Tutorial for Beginners: Complete Getting Started Guide

Yes, the AI Engineering From Scratch repository offers a structured, self‑contained curriculum with three distinct entry points and a dedicated Phase 0 lesson that teaches complete newcomers how to set up their development environment and run their first code.

This open‑source project—available at rohitg00/ai-engineering-from-scratch—is designed as a zero‑to‑production learning path. Whether you prefer reading online, cloning code locally, or taking a placement quiz to find your level, the repository provides concrete tutorials rather than abstract documentation. The following sections break down exactly how beginners can start, what the first lesson covers, and how the curriculum is organized.

---

Three Entry Points for Beginners

The repository’s top‑level README.md describes a four‑layer stack (system → runtimes → package managers → AI/ML libraries) and routes newcomers through one of three starting paths:

1. Read online – Visit the companion site aiengineeringfromscratch.com to consume lessons in a browser without installing anything.
2. Clone & run – Execute the first “Hello‑world” lesson locally after a minimal setup.
3. Find your level – Take an interactive placement quiz that maps your existing knowledge to a personalized learning path.

Each option is documented in the Getting Started section of README.md, allowing you to choose the least‑friction route for your learning style.

---

The First Tutorial: Dev Environment Setup

The concrete starting point for every beginner is the Dev Environment lesson in Phase 0. Located at phases/00-setup-and-tooling/01-dev-environment/docs/en.md, this tutorial walks you through:

• Installing Python 3.11+, Node 20+, and Rust.
• Configuring virtual environments with uv (the modern Python package manager).
• Verifying GPU access for future deep‑learning workloads.

After completing the instructions, you validate your setup by running the verification script:

python phases/00-setup-and-tooling/01-dev-environment/code/verify.py

If successful, you will see imports for NumPy, PyTorch, and a GPU check (if available). This confirms your environment matches the curriculum’s requirements before you proceed to actual AI engineering topics.

---

Lesson Structure: Docs, Code, and Outputs

Every lesson in the repository follows a uniform layout under phases/<NN>-<phase-name>/<MM>-<lesson-name>/. This consistency lets you explore any topic in isolation while preserving a predictable learning rhythm:

Folder	Purpose
docs/	Narrative explanation, learning objectives, and theory.
code/	Runnable implementations in Python, TypeScript, Rust, or Julia.
outputs/	The artifact produced (e.g., a prompt, skill, agent, or MCP server).

For example, the first math lesson (phases/01-math-foundations/01-linear-algebra-intuition/) contains a code/vectors.py file you can execute immediately:

# Run the first Python lesson after cloning:

# python phases/01-math-foundations/01-linear-algebra-intuition/code/vectors.py

# The script prints a simple dot product, confirming the environment works.

This structure ensures that beginners always have three ways to engage: read the narrative, run the code, and inspect the tangible output.

---

Progressive 20‑Phase Curriculum

The curriculum spans 20 phases, allowing you to start at absolute zero and climb toward production‑grade autonomous agents without gaps:

1. Setup & Tooling (Phase 0)
2. Math Foundations (Phase 1)
3. ML Fundamentals (Phase 2)
4. Deep Learning (Phase 3)
5. Computer Vision (Phase 4)
6. Natural Language Processing (Phase 5)
7. Audio & Speech (Phase 6)
8. Transformers (Phase 7)
9. Generative AI (Phase 8)
10. Large Language Models (LLMs) (Phase 9)
11. LLM Engineering (Phase 10)
12. Multimodal AI (Phase 11)
13. Tools & Protocols (Phase 12)
14. Agent Engineering (Phase 13)
15. Infrastructure & Deployment (Phase 14)
16. Capstone Projects (Phases 15‑19)

Each phase builds on the previous one. Phases 0‑2 establish the necessary tooling and mathematical intuition, while later phases teach you to build autonomous agents and MCP servers that can be deployed in production.

---

Reusable Artifacts and Portfolio Building

A defining feature of this tutorial for beginners is that every lesson ships a ready‑to‑use artifact. These artifacts include:

• Prompts for LLM interactions.
• Skills (reusable functions wrapped as tools).
• Agents (autonomous systems that use skills).
• MCP servers (Model Context Protocol implementations).

By the end of the curriculum, you will have built approximately 500 such artifacts, each stored in the lesson’s outputs/ folder. These artifacts can be pasted into any AI assistant or imported into downstream projects, giving you a concrete portfolio that demonstrates hands‑on experience.

As noted in the repository documentation: “Every lesson ships something you can use immediately.”

---

Code Example: Building Your First Skill

Once you reach Phase 13 (Tools & Protocols), you will write a minimal TypeScript skill. The lesson at phases/13-tools-and-protocols/01-the-tool-interface/code/skill.ts can be executed as follows:

# Build a minimal TypeScript skill (Phase 13, Lesson 01)

npx ts-node phases/13-tools-and-protocols/01-the-tool-interface/code/skill.ts

# This prints a JSON schema representing a simple tool definition.

This example demonstrates how the curriculum bridges multiple languages—you learn AI engineering concepts in Python for ML, Rust for performance‑critical components, and TypeScript for agent tooling.

---

Summary

• Three beginner entry points are documented in README.md: read online, clone & run, or take a placement quiz.
• Phase 0, Lesson 01 (phases/00-setup-and-tooling/01-dev-environment/docs/en.md) is the mandatory starting tutorial for environment setup.
• Uniform lesson structure (docs/, code/, outputs/) ensures every topic is learnable in isolation.
• 20 progressive phases move from system setup to production agent engineering.
• 500+ reusable artifacts are built throughout the curriculum, creating a tangible portfolio.

---

Frequently Asked Questions

How do I know if I am a true beginner or should skip ahead?

The repository provides an interactive placement quiz (Option C in the Getting Started section of README.md). This quiz maps your current knowledge—whether in Python, linear algebra, or LLM internals—to a personalized learning path, ensuring you do not waste time on concepts you already understand.

What software do I need to install before starting?

The Dev Environment lesson (Phase 0, Lesson 01) requires Python 3.11+, Node 20+, and Rust. It also recommends the uv package manager for Python environments. After installation, running phases/00-setup-and-tooling/01-dev-environment/code/verify.py confirms that NumPy, PyTorch, and GPU drivers are functional.

Can I complete lessons without installing anything locally?

Yes. Option A in the Getting Started section directs you to aiengineeringfromscratch.com, where the full curriculum is available as readable documentation. However, to run the code/ examples and generate the outputs/ artifacts, you will eventually need a local environment.

What programming languages are used in the tutorials?

The curriculum teaches Python for machine learning and deep learning, TypeScript for agent tooling and MCP servers, Rust for performance‑critical components, and Julia for numerical computing where specified. Each lesson’s code/ folder indicates which language is primary for that topic.

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