How an LLM works, and what to learn around it
Seven layers of what an engineer moving into AI needs to know, from the math under a language model to the hiring market around it, each explained in plain words.
Start hereLLM: how the model works →
What the model does, one token at a time
Every layer below is about some part of this loop: the math it runs on, how it is trained, how it is served, and what gets built with it.
1Tokens
The464best1266way835to284learn2193is318to284
Your text, cut into pieces the model knows, each with a number.
2Vectors
Each token becomes a list of numbers that stands for its meaning.
3Layers
Dozens of layers let every token look back at the others and update its numbers.
4Next-token scores
- build
- start
- practise
- read
- code
Every token it knows gets a probability. These are the top five.
5Add it and go again
Thebestwaytolearnistobuild
The longer sentence goes back in, one token at a time, until the model picks the token that means stop.
Seven layers around it
From the bottom up, in prerequisite order: the higher the layer, the closer to the job and the faster it changes. Each layer is a page.
L6 Careers and the market
What roles exist in this line of work, what they ask for, how to prepare
- Half-life
- Fastest
- How to read
- Read closely when you're preparing to job hunt
L5 The field, part I: history · The field, part II: the frontier
Where this field came from, and what is happening in it each week
- Half-life
- History is stable; the frontier is a stream
- How to read
- Learn the history once; follow the frontier a little each week and let it go once read
L4 Application engineering
Taking a ready-made model and building a product you can rely on
- Half-life
- Fast (months)
- How to read
- Build projects while reading the official docs; come back once a quarter
Working with it · L4–L6
The model
How it works · L0–L3
L3 Systems and infrastructure
How many machines it takes to train and run a model, and where the money goes
- Half-life
- Fast
- How to read
- Read the official docs, then deploy once yourself
L2 LLM core
How a large language model is built from scratch
- Half-life
- Slow (1–3 years)
- How to read
- Learn once, review once a year
L1 ML and deep learning basics
How a machine learns to do something from examples, and why it sometimes learns the wrong thing
- Half-life
- Stable
- How to read
- Learn once
L0 Math and CS foundations
The bit of math behind neural networks: matrices, probability, derivatives, enough to read the formulas
- Half-life
- Stable
- How to read
- As needed: wherever you get stuck, come back and fill in that piece
How to read it
Half-life is a borrowed term: how long it takes for half of a layer's knowledge to go out of date. Math stays the same for decades, so learning it once lasts many years; the tools of application engineering turn over every few months, so for those layers you learn only the principles and the official docs, and don't hoard tutorials. The higher the layer, the closer it is to everyday work, and the faster it changes.
Where to start: if you've already called a large model's API at work, start from L4, and when you hit "why does it do that?", dig down to L2 and L1; when you're getting ready to change jobs, read up into L5 and L6. If you want a solid foundation, read straight from L0 to L6; each layer uses only knowledge from the layers below it.
How to read each layer: first read the lecture at the top of the page. It is the layer's first class: what problem the layer solves, how the concepts in it link into one line, and what you can skip for now. Then read the nodes one by one: each node explains one concept, and under it hang a few picks, the resources we chose as most worth your time, each with a note on "why this one". Finally, do the Self-check: once you can answer every item, you've finished the layer.
The seven layers are the same for everyone; how much effort you put into each is not. People who build products, people who train models and people who work on inference systems each need to work differently hard on each layer. That is what a profile is for: each profile gives the seven layers a weight each, plus a learning path that passes through the nodes in order.
core: other nodes build on it, and the profiles' paths run through it
Under each node at most 3 hand-picked resources: the best free one, a paid one only when it is clearly better, and a project. Ranking never looks at commissions (how we pick).
How much of each layer you need
The layers are neutral; a profile says how much of each you need and in what order.
| Layer | AI Product Manager (sketch) | FDE / AI Engineer | Inference and training infrastructure (sketch) | ML Engineer (sketch) |
|---|---|---|---|---|
| L6 | medium | high | high | high |
| L5 | high | medium | medium | medium |
| L4 | high | highest | low | medium |
| L3 | low | medium | highest | medium |
| L2 | medium | high | high | high |
| L1 | low | medium | medium | high |
| L0 | low | low | medium | medium |
Your route through it
Every route starts with Foundations. The stages come in the order you need them; inside a stage, skills come in the order this month’s job posts ask for them. Each stop links to its node, where the picks are. Demand as of 2026-11-19.
Every route starts here
Foundations
The AI groundwork every other track assumes, for engineers who already ship software: how the models work, calling them from code, search by meaning, classical ML and PyTorch, and measuring what comes out. No programming lessons; the math when a step needs it.
How the models work
as needed
Pick up the linear algebra, calculus and probability a later step leans on, at the moment it leans on them.
26% of technical postings (n=5,004) · about 1 week
Explain how a language model is trained and what it does, token by token, when it answers you.
Call a model from code
about 3 days
Make streaming, tool-using and structured calls to a model API, and account for their tokens, latency and cost.
5% of technical postings (n=5,004) · about 3 days
Improve a prompt against a test set rather than by feel.
Search by meaning
about 3 days
Explain what an embedding captures, build a vector search, and say when keyword search still wins.
Machine learning, the classical way
about 1 week
Split, train, validate and pick a metric for a model on tabular data, and recognise overfitting when it happens.
8% of technical postings (n=5,004) · about 2 weeks
Build and train a small neural network in PyTorch, from tensors and autograd up.
Checkpoint: A network from tensors up — Train a small multilayer network on a classic dataset with your own training loop, then find and fix one bug by reading its loss curve.
Measure it
21% of technical postings (n=5,004) · about 1 week
Turn error analysis on real outputs into an eval you run on every change.
Role route
Forward Deployed Engineer
After the foundations: build an agent on a customer's own data and tools, prove it works with their examples, run it inside their environment, and adapt the model when prompting is not enough.
Build on the customer's data and tools
33% of FDE / Applied postings (n=1,074) · about 1–2 weeks
Build a tool-using agent for someone else's workflow, with step limits and error handling you can explain.
17% of FDE / Applied postings (n=1,074) · about 1 week
Retrieve from the customer's own documents and measure how often the right passage comes back.
3% of FDE / Applied postings (n=1,074) · about 3 days
Expose the customer's systems to the agent through MCP, with tool descriptions tuned until it picks them correctly.
Prove it works
28% of FDE / Applied postings (n=1,074) · about 1 week
Build an eval set from the customer's real cases and report quality in their terms before and after each change.
Checkpoint: An eval report a customer can read — Fifty real cases from one workflow, labelled with the person who does the work today; a before-and-after table for one change, and the three failure types that remain.
Deploy into their environment
TypeScriptLikely “Already know” with 5+ years as a software engineer
15% of FDE / Applied postings (n=1,074) · about 3 days
Read and change the TypeScript front ends and SDKs a customer integration touches.
KubernetesLikely “Already know” with 5+ years as a software engineer
11% of FDE / Applied postings (n=1,074) · about 1 week
Deploy and debug a service on a cluster you do not own.
Adapt the model
8% of FDE / Applied postings (n=1,074) · about 2 weeks
Fine-tune a small model for one narrow customer task and compare it with a prompted frontier model on quality, latency and cost.
Role route
AI Engineer
After the foundations: retrieval, agents and tools in a product, measured; then changing the model itself when prompting stops being enough, and serving it at a cost the product can carry.
Build LLM features
46% of AI / ML Engineer postings (n=183) · about 1–2 weeks
Write a tool-using agent loop yourself and measure where it fails.
37% of AI / ML Engineer postings (n=183) · about 1 week
Retrieve the right context for a question and measure how often you do.
5% of AI / ML Engineer postings (n=183) · about 3 days
Expose a real system to agents through MCP, and measure whether they use it correctly.
Measure and improve
61% of AI / ML Engineer postings (n=183) · about 1 week
Turn error analysis on production traces into evals that gate every change.
18% of AI / ML Engineer postings (n=183) · about 2 weeks
Fine-tune a small open model on one narrow task and prove it beats a prompted baseline.
Train and post-train
25% of AI / ML Engineer postings (n=183) · about 3 weeks
Train a small language model and change one design choice with an ablation to show for it.
18% of AI / ML Engineer postings (n=183) · about 2 weeks
Post-train a small model with preference or verifiable rewards, and see where it games the reward.
Serve it
5% of AI / ML Engineer postings (n=183) · about 1 week
Serve an open model and measure latency and throughput under load.