Async

What is AI engineering? (read this first)

Read this lesson before installing tools or writing code. It explains what AI engineering actually is, what you should know before Session 1, and how the five live sessions stack into your capstone project.

Tip

Take your time

This is reference material, not a race. Bookmark it and come back when a concept clicks during a live session.

Done when

  • You understand what AI engineering is (and is not)
  • You know what is mandatory vs good-to-have before Session 1
  • You are ready to install your coding agent in the next lesson

What AI engineering actually is

AI engineering is the discipline of building reliable products on top of frontier models.

It is not model training. You will almost never train a model from scratch, and in 2026 you will rarely fine-tune one either. It is also not prompt tinkering. Writing a clever prompt is to AI engineering what writing a clever SQL query is to backend engineering: useful, but nowhere near the whole job.

The job is everything in between: grounding models in your data, giving them tools, orchestrating multi-step agents, measuring whether the system actually works, and shipping something that holds up when real users touch it. Models are non-deterministic. The engineering is in building dependable systems out of undependable parts.

One more shift that defines the role right now: coding agents write most of the code. Tools like Claude Code and Cursor handle implementation, which means the scarce skill is no longer typing Python quickly. It is systems thinking, context engineering, and the judgment to evaluate what the agent built. That is what this page, and the bootcamp, are organised around.

What you need before Session 1

AI engineering is still engineering. Before the AI-specific pillars mean anything, you need the same baseline every backend engineer has. We do not spend live session time on these - we assume working familiarity and point you to gap-closers in pre-course.

Python

The working language of the field. You should read and debug it comfortably, even when a coding agent writes most of it.

Official Python tutorial

Git and GitHub

Version control is non-negotiable, and doubly so when an agent commits code you need to review. Branch, commit, diff, revert, open a pull request.

Introduction to GitHub (GitHub Learn)

The command line

You will live in a terminal: environments, paths, processes, logs.

The Missing Semester (MIT)

APIs and HTTP

Requests, responses, status codes, auth headers, JSON. Every LLM call is an API call.

FastAPI docs

Docker

Containers are how AI systems ship. You should be able to read a Dockerfile, build an image, and run a container.

Docker getting started

CI/CD

Automated tests and deploys on every push. Your evals will eventually run here.

GitHub Actions quickstart

Testing

The habit of proving code works. Evals are tests for non-deterministic systems, so the instinct transfers directly.

pytest documentation

Databases and SQL

Where your app's data lives, and increasingly where your vectors live too.

SQLBolt

The bar is working familiarity, not mastery. If you have shipped any software professionally, you likely clear it already. If two or more of these are new to you, spend time on the gap-closers first, or start with the Builder's Bootcamp instead.

The six pillars we teach

On top of engineering foundations sits the AI-specific stack. Every serious AI engineering role in 2026 draws on the same six pillars. Here is each one and what you should be able to do by the end.

1

Foundations

How LLMs behave and how to direct them. Tokens, context windows, structured outputs, tool calling, and context engineering - deciding what the model sees and when.

You can: Call model APIs with structured outputs and tool use, and reason about why a model behaved the way it did.

2

RAG and embeddings

Grounding models in data they were never trained on. Embeddings, chunking, vector search, retrieval strategies, and knowing when RAG is the wrong answer.

You can: Build a retrieval pipeline that surfaces the right context, and defend the chunking and retrieval choices you made.

3

Agents and orchestration

Systems that plan, act, and use tools across multiple steps. Agent patterns, state with LangGraph, MCP, and skills-based patterns like Hermes.

You can: Ship an agent that completes a real multi-step task and recovers when a step fails.

4

Evals

The pillar that separates engineers from tinkerers. Measuring whether the system works, catching regressions, and deciding ship or hold with evidence. We teach this through TRACE.

You can: Write an eval suite for your own system, run it, and make a ship decision from the results.

5

Memory

Agents that learn across sessions instead of starting cold every time. Memory architectures, temporal knowledge, and context compression.

You can: Add persistent memory to an agent and explain what it remembers, forgets, and why.

6

Production

Token cost, latency, caching, model routing, batching, observability, and guardrails - what decides whether your system survives real users.

You can: Cut cost and latency without cutting quality, and prove it with your evals.

How the bootcamp maps to the pillars

Every skill falls into one of three lanes: taught live, practised async on your capstone, or self-study prerequisite with curated links.

Skill areaLiveAsync / self-study
Engineering foundations (Python, Git, CLI, APIs, Docker, CI/CD, testing, SQL)Not taught live - assumedPre-course setup + gap-closer links below
FoundationsSession 1: reliable reasoning, structured outputs, context engineeringCoding-agent workflow, Think Like an AI Engineer series
RAG and embeddingsSession 2: embeddings, chunking, retrieval, when not to RAGGround your capstone in your own data
Agents and orchestrationSession 3: LangGraph, tools, MCP, HermesExtend your capstone agent with real tools
EvalsSession 4: TRACE evals (shared with the Builder's cohort)Eval suite on your capstone before Demo Day
MemorySession 5: memory architectures and persistent stateAdd memory to your capstone and deploy
ProductionThreaded through every live sessionToken optimisation deep dives in Session 1 async work

What happens live

Five live sessions, then a two-week build sprint to Demo Day. Each session is a working session, not a lecture: we build, break, and reason about real systems together, and every session ends with something running on your capstone - the project you choose.

  1. Session 1 - Foundations

    Turn a model call into a reliable component: context engineering, structured outputs, guardrails, and cost visibility.

  2. Session 2 - RAG and embeddings

    Ground your capstone in real data, and learn when retrieval is the wrong tool.

  3. Session 3 - Agents

    Ship an autonomous agent with LangGraph, tools, and MCP.

  4. Session 4 - TRACE evals

    Measure your system like an engineer - masterclass shared with the Builder's cohort.

  5. Session 5 - Memory

    Make your agent persist and compound across sessions.

What happens async

The async work is where the pillars become yours. One capstone runs through the whole course, and each session's assignment adds a layer: retrieval, agency, evals, memory. By Demo Day you have a deployed, evaluated agentic system - not a folder of exercises.

  • Pre-course: coding-agent setup, Python, GitHub, capstone seed, building in public.
  • Token optimisation and production-minded deep dives (Session 1 async modules).
  • Mastering AI Engineering: curated continuation path after the course.

Budget 6 to 8 hours a week including the live session.

Free resources to start now

You do not need to wait for a cohort. These are the resources we point every student to, in the order we would use them.

From The AI Internship

The book: AI Engineering by Chip Huyen (O'Reilly) - read alongside the course, not instead of building.

Where to go next

Enrolled or exploring: start with pre-course setup, then work through the session modules below. The syllabus is the course - this introduction is the map.