The Applied AI Engineering Ladder
Most agent projects fail for a boring reason. The team skipped a rung.
They wire a model to a database and some tools, watch it work once in a demo, and ship it. Then it hallucinates a refund, gets talked into ignoring its own instructions, or quietly burns a fortune in tokens on a loop nobody measured. The post-mortem always finds the same thing: a skill three levels down that nobody learned, because the demo looked fine without it.
AI engineering is a ladder. Nine rungs, and each one stands on the one below. This post is the map of all nine, and the argument for climbing them in order.
It Is Not the Math You Think It Is
The obvious objection writes itself. AI engineering means machine learning, machine learning means gradients and linear algebra, and you did not sign up for that. So you either grind through a maths course you will never use, or you decide the whole field is not for you.
Both moves are wrong, because the premise is wrong. AI engineering is the discipline of building systems on top of models that already exist. You are not training the model. You are steering it, feeding it, giving it tools, bounding it, measuring it, and shipping it. Every one of those is an engineering skill you already have a version of. None of them is a proof.
The math belongs to the people who build the models. You build with them, the way you build with a database without deriving B-trees. What you do need is the vocabulary, tokens, context, retrieval, guardrails, evals, because you cannot reason about a system whose parts you cannot name. That vocabulary is what the ladder teaches, one rung at a time.
A second layer of vocabulary sits further out still. Words like pretraining, fine-tuning, RLHF and LoRA, or the classic machine-learning terms like overfitting and backpropagation, are worth recognising because interviewers say them and papers assume them. But you will never implement them here. You learn them the way you learn a menu in a language you do not speak: enough to know what you are pointing at, not enough to cook it. This course keeps that recognition-only vocabulary clearly walled off from the path you actually build on, so the main climb stays focused and nothing useful goes missing.
What You Need Before You Start
This ladder starts one rung off the ground, not on it. You need to be able to program, in whatever language you already know, and you need to have called an API from code at least once: sent a request, parsed the JSON that came back, handled the error when it did not. That is the whole entry fee.
You do not need machine learning. No statistics, no linear algebra, no single line of PyTorch. If gradients and loss functions mean nothing to you, you are exactly the reader this was written for. Everything from here is an engineering skill wearing unfamiliar words, and the words get explained the moment they arrive.
Each Rung Assumes the One Below It
A ladder is the right shape because the dependencies are real, not decorative. You cannot debug a retrieval system if you do not know what an embedding is. You cannot secure an agent whose control loop you have never traced. You cannot measure quality you cannot define. The lower rung is not a prerequisite in the schoolteacher sense. It is load-bearing. Stand on it or fall.
Here is the whole climb, bottom to top.
Level 1, Foundations. What the model is actually doing under every call: next-token prediction, tokens, embeddings, attention, the context window, sampling, and why it lies with confidence. Get this wrong and every layer above inherits your confusion. How a Language Model Works opens the engine, and the earlier What an LLM Actually Is is the shortest version of the same idea.
Level 2, Communicating. Now you drive it. A prompt is an interface, not a wish. The real product of this rung is machine-readable output: structured responses and function calls your code can parse and trust. Talking to Models is where the chatbot becomes a component.
Level 3, Knowledge. A model only knows what it was trained on. This rung teaches it to answer from your data, on demand, without retraining: chunking, vectors, hybrid search, reranking. Giving Models Your Knowledge is how retrieval beats fine-tuning for almost everything you will build.
Level 4, Tools. Knowledge lets a model read the world. Tools let it act on it. This is the hinge where a chatbot becomes an actor, running the call-result-continue loop until the job is done. Giving Models Tools covers the agentic loop and why MCP kills the bespoke glue.
Level 5, Single agents. Everything below becomes one autonomous unit: something that plans, acts, remembers, and corrects itself toward a goal. An agent is not a model, it is an architecture around one. Building a Single Agent covers the reasoning patterns and the memory that holds a run together.
Level 6, Many agents. When one agent is not enough, you coordinate several. This rung comes with an honest warning: most problems never need it, and reaching for it early is a common way to turn a working system into a slow, expensive one. When One Agent Is Not Enough tells you when the cost is worth it, and usually it is not.
Level 7, Safety. A demo that works once is not a product. This rung is guardrails, prompt injection, least privilege, sandboxing, human approval, and failing gracefully instead of catastrophically. Agents You Can Trust is the rung the failed projects skipped.
Level 8, Evaluation. If you cannot measure an agent, you cannot improve it, and "it looked fine when I tried it" is not measurement. Harnesses, benchmarks, and using a model as a judge turn vibes into numbers. Measuring Agents is how you stop guessing.
Level 9, Production. Shipping. How models are served, what they cost under load, how you see inside a running agent, and how a long job survives failure. Shipping Agents ties every rung below it into one system that stays up. If the phrase zero-downtime sounds like something you buy, the Raspberry Pi deploy shows it is one moved pointer.
Skipping Rungs Is the Whole Failure Mode
Look again at the projects that fall over. The refund hallucination is a missing Level 8: nobody built an eval that would have caught it. The agent talked into ignoring instructions is a missing Level 7: no guardrail, no least privilege on the tool it abused. The token bill nobody saw coming is a missing Level 9: no observability, no budget. The retrieval that returns garbage is a shaky Level 1: an embedding treated as magic instead of geometry.
Every one of these is a team that jumped to Level 5, built an agent that demoed well, and never laid the rungs the demo was quietly borrowing against. The demo works because the failure cases have not happened yet. Production is where they all happen at once.
The order is not bureaucracy. It is the difference between a system you understand and a system you are hoping about. You can borrow a working demo from a framework in an afternoon. You cannot borrow the understanding of why it breaks, and that understanding is exactly what the lower rungs are.
What the Climb Leaves You With
Finish the nine rungs and you can do the things the failed projects could not. You can reason about why a model behaves the way it does and what a given request will cost. You can force structured output your code can trust, and build retrieval that returns the right passage instead of a plausible wrong one. You can wire tools and MCP so the model acts on the world, stand up a single agent and debug it when it loops on itself, and know, from evidence rather than fashion, the rare moment a second agent earns its keep. You can bound an agent so a hostile input cannot turn it against you, measure it so improvement is a number instead of a mood, and ship it so it stays fast, visible, and alive under real traffic.
That is the full skill set of an applied AI engineer. It is nine rungs of engineering, not a mathematics degree, away.
Start at the Bottom
So the ladder is the plan. Nine posts, one per rung, each building the vocabulary and the mental model the next one stands on. You do not have to read them in order, but you do have to understand them in order, because the model does not care which parts you skipped.
Start at Level 1. Learn what the engine is doing before you try to steer it. The engineers whose agents survive contact with real users are not the ones who know the most math. They are the ones who never skipped a rung.