In What Order Should You Learn AI?

A dependency-ordered path through AI concepts, from tokens to agents — plus three routes depending on how deep you actually need to go.

Most AI learning material is a pile, not a path. Each article assumes you already know the thing that would have explained it. So people read about attention before embeddings, get lost, and conclude the material is too hard.

The concepts have a genuine dependency order. Here it is.

The 17 layers

The first seven are the main path. The rest go deeper, and most people need only some of them.

1 · Entry — what these tools do, what they cannot do, and the vocabulary. Orientation, no prerequisites.

2 · ML Foundations — neural networks, how data becomes numbers, gradient descent, backpropagation. The classical machine-learning groundwork that modern models are built on.

3 · Classic NLP — word vectors, recurrent networks, sequence-to-sequence, why transformers won. How language was handled before attention, and what changed.

4 · Foundations — tokens, LLMs, embeddings, generation. The vocabulary everything else assumes.

5 · Internals — transformers, self-attention, positional encoding. How it works, not just what it does.

6 · Prompting — basics, context windows, hallucination, few-shot. Where most practical value is.

7 · RAG — why it exists, the pipeline, chunking. Connecting models to your own documents.

8 · Agents — tool calling, the loop, failure modes. Models that act, not just answer.

9 · Application — API calls, model choice, evals. Shipping something real.

10 · Evaluation — accuracy, confusion matrices, ROC-AUC, why evaluation is hard. How you know whether any of it works.

11 · Multimodal — images, vision-language models, speech, documents. Beyond text.

12 · Training and adaptation — fine-tuning, LoRA, alignment, reasoning models. How models are made and modified.

13 · Advanced architecture — mixture of experts, long context, serving. Where the engineering constraints live.

14 · Advanced RAG — hybrid search, query rewriting, reranking, evaluation. What separates a demo from a working system.

15 · Advanced agents — context engineering, memory, coding agents, evaluation.

16 · Security — prompt injection, guardrails, PII. Read before shipping anything that reads untrusted content.

17 · Production — observability, reliability, cost, migration. Keeping it working.

The dependencies that actually bite

Four places where skipping ahead reliably fails:

Tokens before everything. Cost, context limits, and a family of odd failures are all denominated in tokens. Skip it and three later topics stay foggy.

Embeddings before attention. Self-attention is a procedure for letting vectors update each other by relevance. Without vectors, there is nothing for the mechanism to operate on. This is the single most common ordering mistake.

Hallucination before RAG. RAG is a solution. Learn it before the problem and it is just a pipeline diagram you will not remember.

Prompting before agents. An agent is a loop around prompts plus tools. Weak prompt intuition means unexplainable agent failures.

Three routes

You do not need all 150 articles. Pick by what you actually want.

Beginner — “I want to use these tools well” · 34 articles

Layers 1, 2, and 4, plus the two mechanism pages worth the detour and three practical pages.

What Is AI → What AI Can and Cannot Do → Token → What Is an LLM → Embedding → Generation → How a Transformer Works → Self-Attention → Prompt Basics → System Prompts → Context Window → Hallucination → Few-Shot → Prompt Debugging → Why RAG Exists → Your First API Call → Model Choice

That route covers 34 articles in all — about 39.8 hours. This page and the jargon decoder are the reference to come back to.

Two of these are visual explainers, and they are here on purpose. Transformers and self-attention are usually filed under “advanced,” which is backwards — they are exactly the mechanisms that prose explains badly and pictures explain well. You do not need them to write a prompt, but understanding them is what turns the rest of this material from rules into reasons.

You will understand your tools, your bill, and your failures. You will not know what a KV cache is, and you will not need to.

Intermediate — “I want to build with them” · 121 articles

Everything above, plus RAG and agents in full, plus enough internals to debug (transformers, self-attention), plus the layers that separate a demo from a working system: advanced RAG, advanced agents, security, and production.

About 157 hours. This is the route for most engineers — read internals for intuition, not to reimplement.

Expert — “I want to know how it actually works” · 146 articles

Everything except the four orientation pages, including the deep architecture most people skip: KV cache, why long contexts cost so much, mixture of experts, state space models, speculative decoding, quantization.

About 193 hours. These are where the engineering constraints live. Skip them and performance decisions stay mysterious.

How to read

Do not read straight through. Read a layer, build something small with it, come back. The concepts stick when they explain something you just hit.

Every page here shows its position — its layer, its prerequisites, what comes next, and its recommendation score for each of the three routes. If you land from a search, that header tells you whether you have the background yet.

Skipping is fine if you know what you skipped. Building a RAG system without understanding attention is entirely reasonable. Just know that when retrieval quality gets strange, reranking will be your next stop.

What to remember

• The dependency order is real: tokens → embeddings → attention, and hallucination → RAG.
• Three routes: use-them (34 articles), build-with-them (121), understand-them (146).
• Read a layer, build something, come back.

Next: What Is a Token? — the first real concept, whichever route you take.