AI Engineering — Syllabus & How to Use This Course
This course teaches AI engineering: how to build, evaluate, and ship production software on top of large language models and the agents built from them. It is for software engineers who can already program but have not yet built with LLMs, and for practitioners who have wired up a chatbot or two and now want the conceptual spine underneath the frameworks — so you can reason from the model up instead of from the SDK in.
You do not need a machine-learning background. The first module builds the necessary intuition from the modeling objective up. You do need to be comfortable reading Python, working in a terminal, and thinking about HTTP APIs and JSON.
What you'll be able to do
- Explain what an LLM does at inference time — next-token prediction, attention, tokenization, the training pipeline, sampling, and the context window — well enough to debug behavior, not just use it.
- Program a model through its API: prompting and context engineering, reliable structured output, function/tool calling, retrieval-augmented generation, and reasoning-model test-time compute.
- Implement the ReAct loop from scratch and choose between agent-loop variants (Reflexion, Plan-and-Execute) on the merits.
- Connect an agent to tools and data with the Model Context Protocol, and explain what a harness and a CLI coding agent actually do.
- Navigate the framework and vendor ecosystem (LangGraph, LlamaIndex, CrewAI, AutoGen, the OpenAI Agents SDK, Pydantic AI; the frontier labs; Claude, Gemini, Codex) without getting locked in.
- Decide when a multi-agent system earns its complexity — and design the orchestration when it does.
- Evaluate models and agents against the right benchmarks (MMLU, GPQA, SWE-bench, GAIA, τ-bench) and instrument them in production.
- Read the canonical papers and ship a working agent as your capstone.
Prerequisites
- Python reading fluency — you can follow a class, a function, and a loop. You won't write much, but examples are in Python.
- Command-line basics — running a script, setting an environment variable.
- HTTP + JSON literacy — you know what a POST request and a JSON object are.
No prior ML coursework is assumed. Linear algebra and probability help for the LLM module but are not required — the conceptual content is built up, not dropped on you.
The roadmap
Modules are designed to be read in order; each builds on the last. The dependency structure:
| # | Module | Lessons | Anchor source |
|---|---|---|---|
| 01 | Large Language Models | 6 | Vaswani et al., Attention Is All You Need |
| 02 | Programming the Model | 5 | OpenAI / Anthropic API docs; Lewis et al., RAG |
| 03 | Agents & Agent Loops | 5 | Yao et al., ReAct; Anthropic, Building Effective Agents |
| 04 | Agent Infrastructure | 4 | Model Context Protocol spec |
| 05 | The Ecosystem | 4 | Official framework + vendor docs |
| 06 | Multi-Agent Systems | 3 | Anthropic multi-agent system; Cognition |
| 07 | Evaluation & Benchmarks | 3 | SWE-bench, GAIA, τ-bench |
| 08 | Papers & Capstone | 2 | The primary literature |
Time commitment
About 30 lessons at ~30 minutes each ≈ 16–18 hours of focused reading, plus ~10–15 hours of practice and the capstone. A comfortable cadence is one module per week at 3–4 hours/week, finishing in 6–10 weeks. Modules 01–04 are the load-bearing core; if you're short on time, those four plus the capstone are the minimum viable path.
How to study in LearnOS
- Active recall over re-reading. After each lesson, close it and explain the idea back in your own words. Retrieval practice beats passive review for long-term retention (Roediger & Karpicke, 2006).
- Chat with the lesson when a section doesn't land — it retrieves the cited sections so the answer is grounded in what you're reading, not the open internet.
- Flashcards + spaced repetition — review each lesson's deck and let the scheduler pace you.
- Notes & module reviews — keep a running journal; generate a review per module before moving on.
- Build. Every concept here exists to be used. The capstone is the proof you learned it.
The capstone
You'll ship a tool-using ReAct agent: it calls real tools, grounds answers with retrieval, runs inside a small harness you understand end-to-end, is wired to at least one MCP server, and comes with an eval harness and basic observability. It's deliberately the synthesis of the whole course — when it works, you've demonstrated every outcome above. Full spec in 08 · Papers & Capstone.
What this course omits
- Training and fine-tuning LLMs from scratch. This is an engineering course — you'll learn how training works conceptually (Module 01) but not how to run a pretraining job, write CUDA kernels, or fine-tune weights. For that, go to a deep-learning course.
- The deep math of transformers. Attention is taught at the working-mechanic level, not derived.
- Provider-specific exhaustive API reference. The official docs do that better and stay current; this course teaches the durable concepts and points you to the docs for the moving details.
- Frontier capability claims with a short shelf life. Where the truth changes monthly (exact model versions, leaderboard numbers), the course dates the claim and links a live source rather than asserting a number that will rot.
Sources
- Roediger & Karpicke, 2006 — the testing effect: retrieval practice improves long-term retention.
- Anthropic — Building Effective Agents (2024) — the agent vs. workflow framing this course adopts.