Skip to main content

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.

  1. 1Tokens

    The464best1266way835to284learn2193is318to284

    Your text, cut into pieces the model knows, each with a number.

  2. 2Vectors

    Each token becomes a list of numbers that stands for its meaning.

  3. 3Layers

    Dozens of layers let every token look back at the others and update its numbers.

  4. 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.

The tokens and their numbers are GPT-2’s; the vectors and scores are made up to show the idea.

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.

  1. Half-life
    Fastest
    How to read
    Read closely when you're preparing to job hunt
  2. 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
  3. 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

  1. 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
  2. Half-life
    Slow (1–3 years)
    How to read
    Learn once, review once a year
  3. 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
  4. 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).

See the whole atlas on one map →

How much of each layer you need

The layers are neutral; a profile says how much of each you need and in what order.

LayerAI Product Manager (sketch)FDE / AI EngineerInference and training infrastructure (sketch)ML Engineer (sketch)
L6mediumhighhighhigh
L5highmediummediummedium
L4highhighestlowmedium
L3lowmediumhighestmedium
L2mediumhighhighhigh
L1lowmediummediumhigh
L0lowlowmediummedium

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.

  1. How the models work

    • The math, when you need it

      as needed

      Pick up the linear algebra, calculus and probability a later step leans on, at the moment it leans on them.

    • LLMs

      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.

  2. Call a model from code

    • Calling a model API

      about 3 days

      Make streaming, tool-using and structured calls to a model API, and account for their tokens, latency and cost.

    • Prompting

      5% of technical postings (n=5,004) · about 3 days

      Improve a prompt against a test set rather than by feel.

  3. Search by meaning

    • Embeddings and vector search

      about 3 days

      Explain what an embedding captures, build a vector search, and say when keyword search still wins.

  4. Machine learning, the classical way

    • Classical machine learning

      about 1 week

      Split, train, validate and pick a metric for a model on tabular data, and recognise overfitting when it happens.

    • PyTorch

      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.

  5. Measure it

    • Evals

      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.

  1. Build on the customer's data and tools

    • Agents

      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.

    • RAG / retrieval

      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.

    • MCP

      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.

  2. Prove it works

    • Evals

      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.

  3. 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.

  4. Adapt the model

    • Fine-tuning

      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.

  1. Build LLM features

    • Agents

      46% of AI / ML Engineer postings (n=183) · about 1–2 weeks

      Write a tool-using agent loop yourself and measure where it fails.

    • RAG / retrieval

      37% of AI / ML Engineer postings (n=183) · about 1 week

      Retrieve the right context for a question and measure how often you do.

    • MCP

      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.

  2. Measure and improve

    • Evals

      61% of AI / ML Engineer postings (n=183) · about 1 week

      Turn error analysis on production traces into evals that gate every change.

    • Fine-tuning

      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.

  3. Train and post-train

    • PyTorch

      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.

    • RL / post-training

      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.

  4. Serve it

    • vLLM / SGLang / TensorRT

      5% of AI / ML Engineer postings (n=183) · about 1 week

      Serve an open model and measure latency and throughput under load.

Spot a mistake on this page?