How this track works

Why it matters

A language model is a component with awkward properties: dear per call, slow next to a database, non-deterministic, and wrong in ways that never throw. Building a product on one is a systems problem before it is a modelling problem. The engineers hired for AI work in 2026 are the ones who can draw the pipeline around the model, say where it breaks and say how they would measure it. This track exists to make that drawing and that sentence automatic. It assumes you ship production code and have called a model API at least once; it assumes no machine learning.

The idea

The track is four stages, 21 modules and 111 lessons, read in order or entered by module. Each stage is a layer of the system: what the model is and how to talk to it, how it gets knowledge it was not trained on, how it takes actions and when it stops, and how you run the result without losing money or sleep.

The four stages

	Covers	The question it answers
Foundations	Tokens, attention, post-training, the API surface, prompting, context, tool calls	What is this thing and how do I talk to it?
Retrieval	Embeddings, vector search, the RAG pipeline, the advanced tiers, measuring any of it	How does it know about my data?
Agents	The loop, workflow patterns, agent types, memory, multi-agent systems, MCP and A2A	How does it act, and when does it stop?
Operating	Evals, observability, safety, serving and cost, fine-tuning, the interview playbook	How do I run it and defend it in a room?

What a lesson looks like

Every lesson has the same shape. Why it matters names the problem and where it bites. The idea explains the mechanism around one diagram, with a comparison table wherever there is a choice to weigh. Trade-offs lists what you give up and the failures to name before an interviewer does. In an interview gives you the quotable sentence and how deep to go at each level. A quiz targets the commonest wrong intuition, and the takeaways are lines you can say out loud. The shape never changes, so you can read a lesson in eight to fifteen minutes and know where the one fact you need will be.

Depth, Weight and Fit

Three labels on every lesson let you cut the track to the time you have. Depth is Intro, Core or Deep: how far under the surface it goes. Weight is Must-know, Should-know or Nice-to-know: how often it decides an interview. Fit is Junior, Mid or Senior: who is expected to carry it unprompted. Filter on any of them from the track page.

The junior cut is about thirty Must-know lessons: this Orientation module, How language models work, Models and the API, Prompting and context, Tool use fundamentals, The RAG pipeline and The agent loop. Finish those and you can build a document Q&A product and explain every box in it. The senior cut assumes all of that and leans on Advanced retrieval, Memory and state, Evaluation, Safety and security, Serving and cost and the AI interview playbook, which is where the design-round questions about cost, failure and measurement live.

How drills work

A drill closes every module after this one. It is a scenario with real constraints: a latency budget, a token price, a symptom from production. Say your answer out loud before you reveal the model answer, then grade yourself on three things: did you name the mechanism, did you give numbers, did you say how you would measure it. The grade is honest only if the speaking comes first; reading the answer and nodding teaches nothing.

Free, Pro and the neighbouring track

The Foundations stage is free. Retrieval, Agents and Operating are Pro. The track sits beside System Design, and the two meet at the index: the Vector databases lesson there treats the index as a storage system, while the Embeddings and vector search module here treats it as a retrieval component that can be measured and tuned. Read them together when you reach the Retrieval stage.

Trade-offs

The track trades breadth for defensibility. It does not teach you to train a model, and it does not walk through a framework's API, because both go stale and neither is asked in a design round. It teaches the pieces, the failure modes and the numbers, naming vendors only where a fact is vendor-specific. If you want a notebook tutorial, this is not it. If you need to explain to a room why a retrieval system is returning the wrong chunks, it is the shorter path.

In an interview

Orientation is not interview material, but the habit it sets is. For every component you draw: name the mechanism, name how it fails, say how you would measure it. Interviewers listen for the third part. "I would start with a naive pipeline, build a golden set of fifty real questions and measure recall before I touch chunk size" lands harder than any amount of architecture. The last lesson in this module walks the 2026 loop round by round.