Build-First Curriculum

About Learn AI Engineering

A self-paced, build-first roadmap for modern AI engineering — the software engineering discipline as practiced in industry today: LLM applications, agents, RAG, structured outputs, evals, and production deployment.

Curriculum

8 Phases

Execution

Browser WASM

Focus

Projects & Evals

Language

Python Native

What This Roadmap Is (And What It Is Not)

Software Engineering for AI

Modern AI engineering treats models as software components you build products around. This roadmap covers building real software: async API handling, structured validation, retrieval pipelines, agentic execution loops, evaluation suites, and scalable cloud deployments.

Not ML Theory or Kaggle

This is not a machine learning or data science curriculum. There is no calculus, no model training from scratch, no pandas/NumPy notebook loops, and no Kaggle competitions. Prior ML theory is not required; Python is taught from Phase 1 scoped to AI engineering.

Operating Principles

Six non-negotiable guidelines that shape how this curriculum is built and learned.

Build first, read second

Every phase is anchored to a real project. Reading without shipping code doesn't count as progress.

Raw APIs before frameworks

Build the agent loop, RAG pipeline, and structured-output parsing directly against raw APIs once. Then adopt frameworks knowing exactly what they abstract.

One primary tool per category

Depth in one vector DB, one agent framework, and one eval tool beats surface familiarity with five. Learn one deeply before comparing alternatives.

Evals are the core skill

The difference between a weekend demo and a production product is a test suite that tells you when you made things worse. Evals start early and stay load-bearing.

Exit by competence, not calendar

Each phase ends with concrete exit criteria. Move on when you can build and explain the deliverables — whether that takes one week or one month.

AI assistants as teachers, not typists

LLMs and coding agents are built into the workflow. The bar is total comprehension: every piece of generated code must be understood, explainable, and debuggable.

The 8-Phase Curriculum

Phases build directly on each other — projects from early phases are instrumented and deployed in later phases.

Phase 01 Foundations: Python for AI Engineering →

Goal: Learn Python from the ground up — scoped ruthlessly to what AI engineering actually uses — plus the engineering substrate every later phase leans on: typing, async, streaming, a little SQL, and containers.

You build: wrangle, a typed data-cleaning CLI (warm-up), then mockstream, a streaming "fake LLM" web service — typed, tested, Dockerized.

Phase 02 LLMs & Model APIs →

Goal: A working engineer's mental model of LLMs, and real fluency with the APIs — hosted frontier models and local open-weight models — including streaming, failure handling, and cost.

You build: A terminal chat client from scratch, no frameworks, speaking to both a hosted model and a local one.

Phase 03 Prompt Engineering & Structured Outputs →

Goal: Treat prompts as engineered artifacts — versioned, tested, measurable — and make LLMs produce output your code can actually consume: validated JSON and tool calls.

You build: A document-extraction pipeline with a measured accuracy number.

Phase 04 RAG: Embeddings, Vector Search, Retrieval →

Goal: Build retrieval-augmented generation properly — embeddings, chunking, hybrid search, reranking, citations — and know how to measure whether retrieval is actually working.

You build: docs-chat, a grounded Q&A system over a real corpus, with a retrieval eval set.

Phase 05 Agents & Agentic Workflows →

Goal: Build agents three ways — a raw loop, a framework (LangGraph), and an MCP server — and develop judgment about when agency is warranted at all.

You build: All three, sharing one set of tools.

Phase 06 Evaluation, Testing & Observability →

Goal: Make quality measurable and regressions catchable: golden sets, LLM-as-judge, tracing, and evals wired into CI.

You build: A 50+ case eval suite and full tracing for your Phase 4–5 apps, with a regression gate in CI.

Phase 07 Production: Architecture, Deployment & Scaling →

Goal: Ship and operate AI systems: gateway patterns, caching, queues, self-hosted model serving, deployment, security, and cost engineering.

You build: docs-chat, deployed for real — gateway, background ingestion, dashboards, load-tested, budget-alarmed.

Phase 08 Capstone: A Real AI Product, End to End →

Goal: Prove the whole stack by shipping one complete product: designed, built, evaluated, deployed, observable, documented — the artifact that anchors your portfolio and your next interview.

The Toolchain & Technology Stack

One primary tool per category for deep mastery, avoiding tool-hopping fatigue.

Languages & Core Engineering

Python: The core language; every major AI framework is Python-first
PostgreSQL / SQL: Relational data, pgvector embeddings & full-text search
uv: Fast Python package manager replacing pip, venv, and poetry
ruff & pyright: Instant linting, formatting & strict static type checking
Pydantic & FastAPI: Data validation, schemas & async API web services
Docker & GitHub Actions: Containerized local infra & automated CI test/eval gates

Models & Access

Anthropic & OpenAI APIs: Frontier model APIs for streaming, tool use & prompt caching
Ollama: Local runner for open-weight models (Llama, Qwen, DeepSeek)
Microsoft Foundry & Bedrock: Enterprise cloud model platforms with private governance

Structured Outputs, RAG & Agents

Instructor: Pydantic-validated LLM structured outputs with automatic retries
pgvector & Cohere Rerank: Vector similarity search and cross-encoder reranking
LangGraph & MCP: Stateful agent graphs and Model Context Protocol servers

Evals, Observability & Production

promptfoo & DeepEval: Automated regression testing and pytest-native LLM metrics
Langfuse: Open-source LLM tracing, latency tracking & cost monitoring
LiteLLM & vLLM: Unified API gateway and high-throughput GPU model serving
Redis & Modal: Async task queues and serverless GPU execution

Interactive Browser Execution

This site is not just static documentation. Phase 1's Python drills run directly in your browser using Pyodide (WASM). The exact same pytest test suites that live in this repository execute against your submitted code right inside your tab. No local Python installation, cloning, API keys, or accounts are required to start learning.

All site content and drills are derived from phases/ in the git repository, ensuring the site and curriculum documentation never drift apart.

Rough Effort

Phase 1 runs 30–50 hours if Python is new (a fraction of that as a refresher); Phases 2–3 run 15–25 each, Phases 4–7 run 25–40 each, and the capstone is as big as you make it. At ~10 hours/week, that's roughly six months to a defensible, production-grade skillset.

Budget & Hardware

Designed to run on ordinary laptop hardware (local Ollama models on CPU). Total API spend is roughly $50–$150 plus ~$10–$30 for rented serverless GPUs in Phase 7.