# AI Engineering from Scratch Prerequisites: Complete Setup and Curriculum Guide

> Learn AI Engineering from Scratch with our complete setup and curriculum guide. Master prerequisites like Git and Python 3.11+ to build your AI skills.

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

---

**To begin the AI Engineering from Scratch curriculum, you need Git, Python 3.11 or newer, and the ability to write code in any language (Python is most convenient), with each subsequent phase requiring completion of specific previous phases and lessons.**

The **AI Engineering from Scratch** curriculum by Rohit Gupta (`rohitg00/ai-engineering-from-scratch`) is structured as a progressive, phase-based learning path that requires strict adherence to prerequisite chains. Unlike traditional courses that allow random access, this repository enforces a build-upon-previous-knowledge model where each phase's [`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md) explicitly defines the required foundation before you can attempt its lessons.

## General Prerequisites for AI Engineering from Scratch

Before touching any machine learning code, the repository defines two categories of baseline requirements in the root [`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md) and [`phases/00-setup-and-tooling/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/00-setup-and-tooling/README.md).

### Core Technical Skills

- **Programming Ability**: You must be able to write code in any language. Python is the most convenient choice because the entire curriculum uses Python-based labs and examples.
- **Git Installation**: Version control is mandatory for cloning the repository and managing your progress through the phases.
- **Python 3.11+**: The [`phases/00-setup-and-tooling/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/00-setup-and-tooling/README.md) explicitly requires Python 3.11 or newer to ensure compatibility with modern AI/ML libraries used throughout the curriculum.

### Learning Mindset

The root [`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md) emphasizes a **desire to understand how AI works internally**, not just how to call APIs. This curriculum focuses on building systems from first principles rather than using high-level abstractions.

## Phase-by-Phase Prerequisites

Each phase directory contains a [`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md) that acts as a gatekeeper. You cannot skip phases because later lessons depend on specific knowledge from earlier ones.

### Phase 0 – Setup and Tooling

**Required**: Git and Python 3.11+ installed on your system.

[`phases/00-setup-and-tooling/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/00-setup-and-tooling/README.md) specifies that this phase requires **no prior knowledge**. It exists solely to verify your development environment. The repository provides a verification script to confirm your setup:

```bash

# Run the pre-flight verifier from the repository root

python3 phases/00-setup-and-tooling/01-dev-environment/code/verify.py --route beginner

```

If any prerequisite is missing, the script outputs a "Next:" command indicating exactly which lesson to complete.

### Phase 1 – Math Foundations

**Required**: Completion of Phase 0 (or confirmation that Git and Python work correctly).

[`phases/01-math-foundations/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/01-math-foundations/README.md) builds upon the tooling setup, introducing linear algebra and calculus concepts necessary for all subsequent AI work.

### Phase 2 – ML Fundamentals

**Required**: 
- Phase 1 Math Foundations
- Familiarity with **NumPy**

The [`phases/02-ml-fundamentals/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/02-ml-fundamentals/README.md) explicitly lists NumPy familiarity as a non-negotiable prerequisite, as vectorized operations form the basis of the hands-on implementations.

### Phase 3 – Deep Learning Core

**Required**: Phase 1 Linear Algebra intuition (mandatory) and Phase 2 (recommended).

According to [`phases/03-deep-learning-core/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/03-deep-learning-core/README.md), you need the mathematical foundations from Phase 1 to understand backpropagation and gradient descent implemented in this phase.

### Phase 4 – Computer Vision and Phase 6 – Speech & Audio

**Required for both**: Phase 1 vectors, matrices, and probability.

[`phases/04-computer-vision/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/04-computer-vision/README.md) additionally requires **Phase 3 Lesson 11** specifically. Phase 6 ([`phases/06-speech-and-audio/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/06-speech-and-audio/README.md)) shares the same Phase 1 mathematical prerequisites but focuses on temporal signal processing rather than spatial features.

### Phase 5 – NLP Foundations to Advanced

**Required**: Phase 2 Lesson 14 (Naïve Bayes).

[`phases/05-nlp-foundations-to-advanced/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/05-nlp-foundations-to-advanced/README.md) specifies this exact lesson because probabilistic classification concepts are reused immediately in text processing algorithms.

### Phase 7 – Transformers Deep Dive

**Required**: Phase 3 Deep Learning Core **and** Phase 5 Lesson 09 (attention mechanisms).

The [`phases/07-transformers-deep-dive/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/07-transformers-deep-dive/README.md) explicitly gates this content behind understanding both deep learning fundamentals and attention mechanisms from the NLP phase.

### Phase 8 – Generative AI

**Required**: Phase 2 ML Fundamentals, Phase 3 Deep Learning Core, **and** Phase 7 Transformers.

[`phases/08-generative-ai/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/08-generative-ai/README.md) requires all three foundational pillars as generative models combine statistical learning, neural architectures, and transformer backbones.

### Phase 9 – Reinforcement Learning

**Required**: Phase 1 probability and distributions, plus specific Phase 2 lessons.

[`phases/09-reinforcement-learning/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/09-reinforcement-learning/README.md) leverages the probability theory from Phase 1 for policy gradients and Markov decision processes.

### Phase 10 – LLMs From Scratch

**Required**: Phase 5 NLP Foundations and Phase 7 Transformers (strongly recommended).

[`phases/10-llms-from-scratch/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/10-llms-from-scratch/README.md) bridges natural language processing with transformer architectures to build language models from the ground up.

### Phase 11 – LLM Engineering

**Required**: Phase 10 lessons 01-05.

[`phases/11-llm-engineering/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/11-llm-engineering/README.md) requires specific completion of the first five lessons from the LLM construction phase, covering architecture implementation and training basics.

### Phase 12 – Multimodal AI

**Required**: Phase 7 Transformers **and** Phase 4 Computer Vision.

[`phases/12-multimodal-ai/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/12-multimodal-ai/README.md) combines sequence modeling (Transformers) with visual feature extraction (Computer Vision) to process heterogeneous data types.

### Phase 13 – Tools & Protocols

**Required**: Phase 11 LLM completion APIs.

[`phases/13-tools-and-protocols/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/README.md) assumes you can interact with LLM APIs (covered in Phase 11) before introducing Model Context Protocol (MCP) and Agent Skills.

### Phase 14 – Agent Engineering

**Required**: Phase 11 LLM Engineering **and** Phase 13 Tools & Protocols.

[`phases/14-agent-engineering/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/14-agent-engineering/README.md) synthesizes API usage with tool-calling frameworks to build autonomous agent loops.

### Phase 15 – Autonomous Systems

**Required**: Phase 14 Lesson 01 (The Agent Loop).

[`phases/15-autonomous-systems/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/15-autonomous-systems/README.md) specifically requires understanding the fundamental agent execution loop before scaling to complex autonomous behaviors.

### Phase 16 – Multi-Agent and Swarms

**Required**: Phase 14 Agent Engineering, plus **Node.js 20+** and `npx`.

Unique among the phases, [`phases/16-multi-agent-and-swarms/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/16-multi-agent-and-swarms/README.md) introduces JavaScript tooling requirements for distributed agent orchestration.

### Phase 17 – Infrastructure and Production

**Required**: Phase 11 LLM Engineering and Phase 13 Tools & Protocols.

[`phases/17-infrastructure-and-production/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/17-infrastructure-and-production/README.md) focuses on deployment patterns requiring both model serving knowledge (Phase 11) and protocol integration (Phase 13).

### Phase 18 – Ethics, Safety and Alignment

**Required**: Phase 10 Lessons 06-08 on SFT (Supervised Fine-Tuning), RLHF, and DPO.

[`phases/18-ethics-safety-alignment/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/18-ethics-safety-alignment/README.md) requires understanding fine-tuning and alignment techniques before discussing their ethical implications and safety guardrails.

### Phase 19 – Capstone Projects

**Required**: Completion of the listed preceding phases for the chosen project.

[`phases/19-capstone-projects/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/19-capstone-projects/README.md) acts as the final synthesis, requiring you to have completed the specific prerequisite chain relevant to your selected capstone track.

## Verifying Your Prerequisites Programmatically

The repository includes automated verification tools to prevent you from starting a phase unprepared. The verification script checks for required tools and previous lesson completions:

```bash

# Verify readiness for the beginner route

python3 phases/00-setup-and-tooling/01-dev-environment/code/verify.py --route beginner

```

The script exits with code `0` only when all prerequisites are satisfied. If validation fails, it outputs the exact lesson you must complete next, eliminating guesswork from the curriculum path.

## Summary

- **Minimum entry requirement**: Git and Python 3.11+ (Phase 0 only).
- **Mathematical foundation**: Phase 1 (linear algebra, calculus) is required for all deep learning and AI phases.
- **Library dependency**: NumPy familiarity is mandatory starting Phase 2.
- **Strict progression**: Phases 7, 11, 14, and others explicitly require specific lesson numbers from previous phases, not just general phase completion.
- **Tooling expansion**: Phase 16 introduces Node.js 20+ and `npx` requirements for multi-agent systems.
- **Verification**: Use [`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) to check readiness before starting any phase.

## Frequently Asked Questions

### What programming language do I need for AI Engineering from Scratch?

You need the ability to write code in any language, though Python is strongly preferred and used exclusively throughout the curriculum. The [`phases/00-setup-and-tooling/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/00-setup-and-tooling/README.md) assumes Python 3.11+ for all labs and verification scripts, while [`phases/16-multi-agent-and-swarms/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/16-multi-agent-and-swarms/README.md) additionally requires Node.js 20+ for specific multi-agent exercises.

### Can I skip Phase 0 if I already know Git and Python?

No. Even if you have Git and Python 3.11+ installed, you must verify your environment using the verification script in [`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). Additionally, [`phases/01-math-foundations/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/01-math-foundations/README.md) explicitly lists "Completion of Phase 0" as its prerequisite, making Phase 0 a formal gate in the prerequisite chain regardless of prior experience.

### What is the minimum version of Python required?

Python 3.11 or newer is mandatory. This requirement is specified in [`phases/00-setup-and-tooling/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/00-setup-and-tooling/README.md) to ensure compatibility with type hinting features and modern async patterns used in later phases, particularly in Phase 11 (LLM Engineering) and Phase 13 (Tools & Protocols).

### How do I verify I have completed the prerequisites for a specific phase?

Run the pre-flight verification script from the repository root with the appropriate route flag. The script at [`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) checks your tooling installation and lesson completion status, exiting successfully only when you satisfy all dependencies for your target phase. If prerequisites are missing, the script provides the exact command to complete the next required lesson.