The AI Internship
Async

What is AI engineering? (start here)

Start here before tools or code. Work through these steps in order - they give you the mental model the whole bootcamp rests on.

  1. 1

    Know what AI engineering is (and is not)

    It is not model training and not clever prompt tinkering. It is building reliable products on top of frontier models you did not train: grounding them in your data, giving them tools, measuring whether they work, and shipping something that holds up with real users. Models are non-deterministic - the engineering is making undependable parts behave dependably.

  2. 2

    See why coding agents sit at the centre

    Cursor and Claude Code write most of the code. The scarce skill is systems thinking, context engineering, and judgment - directing the agent, reading what it produced, and deciding what to keep or fix. That is how this cohort runs.

  3. 3

    Check the foundations we assume

    Python, Git/GitHub, the command line, APIs/HTTP, Docker, CI/CD, testing, and SQL at a working-familiarity level. We do not teach these live. Pre-course and the gap-closer links below cover what you need before Session 1.

  4. 4

    Learn the six pillars we teach

    Foundations → RAG → Agents → Evals → Memory → Production. Each live session adds one of these layers to your capstone project.

  5. 5

    Map sessions to your capstone

    Session 1 = reliable `/ask`. Session 2 = ground it in your data. Session 3 = agency and tools. Session 4 = TRACE evals. Session 5 = memory and deploy. Async work extends the same project - not five throwaway demos.

  6. 6

    Then do pre-course setup

    After this reading: install Cursor or Claude Code, create a GitHub account, add your OpenAI API key, seed your capstone, and post a short check-in. The Session 1 checklist at the end of pre-course shows mandatory vs good-to-have.

Critical

Before Session 1: coding agent first

Your highest-leverage setup job is installing Cursor or Claude Code and opening a project folder. Do that in the next lesson. Python, API keys, and FastAPI come after - your agent helps with most of it.

Tip

Foundations, pillars, and resources below

Scroll past this card for the foundations list, six pillars, session coverage map, and free resources. Bookmark this page and come back when a concept clicks in a live session.

Done when

  • You can say what AI engineering is and is not in one or two sentences
  • You know the six pillars and which Session maps to each
  • You know to install Cursor or Claude Code next

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.

    Session slides →
  2. →
    Session 2 - RAG and embeddings

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

    Session slides →
  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

Next up: install Cursor or Claude Code, then finish the rest of pre-course setup before Session 1.

Back to Pre-course·Full syllabus

Next

Install Cursor or Claude Code (do this next)