New: Roadmaps ordered paths through our cheat sheets and flashcards, so you always know what to study next.
Explore themSee what's new on GitHubFrom your first prompt to fine-tuning, aligning, and serving models at production scale.
A 15-step learning path. Follow it in order, or jump to what you need.
This path is for developers who already use LLMs day to day and want to see what's actually happening under the hood, not just call an API and hope. Expect about 9 to 12 weeks at a few hours a week, moving from prompting and transformer internals through pretraining and scaling laws, into fine-tuning, alignment, evaluation, and the serving optimizations that keep a model fast and cheap in production. It does not cover agent orchestration, MCP tool wiring, or the interview-facing production build that AI Engineer (LLM Applications) closes on; this path stays inside the model itself. By the end you can reason about why a model behaves the way it does, fine-tune and align it on your own data with LoRA and DPO, and benchmark and serve it with production-grade safety and cost controls.
Expected: some comfort writing and running basic code, plus hands-on experience calling an LLM API or experimenting with prompts. Helpful but not required: prior exposure to classical machine learning training runs.
Start here: reshape a single instruction and watch the model's answer change today, no setup beyond a prompt box, the instinct every step ahead assumes you already have.
Step 1 showed the effect; this shows the cause: tokens, self-attention, and pretraining explain why one phrasing works better than another.
This is where it clicks: multi-head attention and residual stacking are the real mechanism behind step 2's overview, and most learners have to circle back here more than once before it settles.
Zoom out from a single model's internals to how it got built at all: compute budget, token counts, and scaling laws decide what size is even worth training, a tradeoff most engineers never see until they hit it.
You can reshape a prompt, trace why attention makes that work, and explain why scaling laws decide a model's size in the first place. Next up: putting that insight to work through a real API.
Finish this section to unlock.
+100 XP
Take the internals from steps 3 and 4 and put them to work: authenticate against a provider, send a request, and get a response your own code can use.
Turn text into vectors so similarity becomes a distance you can compute, the piece step 7 needs before it can retrieve anything.
Connect step 6's vectors to a live document set and the model finally answers from your data instead of guessing at it.
You can call a provider's API directly and retrieve real facts into context instead of hoping the model remembers them right, and a few due flashcards on chapter 1 keep the scaling-law details fresh while you build on them. Next up: reaching past retrieval into changing the model itself.
Finish this section to unlock.
+100 XP
Instead of feeding fresh context on every call like step 7 does, teach the weights themselves: adapt the pretrained model from step 4 to your own task or domain.
Take this if you're doing hands-on adaptation work on a budget: LoRA freezes the base model and trains a small fraction of its parameters, so step 8's fine-tuning runs on a single consumer GPU instead of a cluster.
Go past step 8's raw fine-tuning into preference alignment: shape which of two answers the model prefers, without training a separate reward model.
Before you trust any of this in front of a real user, score the RAG answers from step 7 and the fine-tuned outputs from step 8 against something other than your own gut.
You can fine-tune a pretrained model on your own data, align it with DPO, and score whether the result actually got better. Next up: proving it can survive contact with real traffic.
Finish this section to unlock.
+100 XP
Reach for this when retrieval quality is your bottleneck: push past step 7's baseline with query rewriting, reranking, and multi-stage retrieval that recovers cases naive RAG misses.
Whatever step 8 fine-tuned or step 10 aligned still has to run fast and cheap in production: quantization, batching, and speculative decoding cut real inference cost without retraining anything.
A model you fine-tuned in step 8 and connected to your own data in step 7 is also one that can be tricked into leaking or misusing both: close the gaps prompt injection and data exposure open.
Pull pretraining choices, fine-tuning, alignment, and safety guardrails into one verdict: benchmark the whole system against recognized suites and decide, with evidence, whether it's actually ready.
You can optimize retrieval, cut real inference cost, close off prompt-injection and data-leak paths, and benchmark the whole system against recognized suites before calling it done. This badge marks that you know what's running underneath, not just how to call it.
Finish this section to unlock.
+100 XP
Finish every required step, at least 70% of them genuinely done (not skipped), to earn this badge and 500 XP.