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

> Start AI Engineering from Scratch with this beginner tutorial. Learn setup and run your first code with our comprehensive guide. Master AI engineering fundamentals today.

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

---

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

```bash
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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/code/vectors.py) file you can execute immediately:

```python

# 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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/01-the-tool-interface/code/skill.ts) can be executed as follows:

```typescript

# 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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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](https://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.