Foundations
An ordered concept spine, beginner to advanced — using AI, agents, orchestration, context.
Start here if you are getting from “I know it’s powerful” to a first real win.
How AI Models Actually Work
After this you can predict when a model will be confidently wrong, because you understand what it is actually doing when it answers, which is guessing the next word rather than looking anything up.
BeginnerThe Model Landscape, Without the Leaderboards
After this you can pick the right model for a task by matching its real requirements (context window, modality, latency, cost, reasoning depth) to a tier, instead of reaching for whatever sits on top of a benchmark leaderboard.
BeginnerAI Product Surfaces: Chat, IDE, Agent, API
After this you can look at a task and pick the right surface for it (chat, IDE assistant, agent, or API) instead of forcing every task through whichever one you happen to have open.
BeginnerPrompting Fundamentals That Actually Move Output
After this you can take a prompt that is giving you mediocre results and improve it on the next try by being more specific and cutting what does not earn its place, rather than piling on more instructions and examples and hoping.
BeginnerShape the Output, Not Just the Content
After this you can specify the *shape* of a model's output so its results drop straight into the next step of your workflow, without forcing the model into a structure that quietly wrecks its reasoning.
IntermediateContext Engineering: Curating the Window
After this you can run the context window as a curated working set.
IntermediateContext Rot in Long Conversations
After this you can tell when a long thread has rotted, name which of four ways it went wrong, and repair it by removing the poisoned tokens instead of appending a correction the model will ignore.
IntermediateMemory: What Persists and What Doesn't
After this you can place any fact where it will actually survive, knowing which things vanish at the next reset and which you have to write outside the window for the model to ever see again.
IntermediateThe Agent Loop: From Answering to Acting
After this you can tell when a task actually needs an agent, build the loop around the model rather than expecting the model to be the agent, and stop the loop before it runs away.
IntermediateTools Are the Model's Hands
After this you can design a tool an agent calls correctly the first time, because the name, the description, the arguments, and the return shape all tell it exactly when to reach for this tool and what it will get back.
IntermediateDesigning the Autonomy Leash
After this you can hand a multi-step task to an agent and bound it, so a long unattended run cannot quietly drift into expensive or irreversible mistakes.
AdvancedMulti-Agent Orchestration: When One Isn't Enough
After this you can judge whether a task actually benefits from multiple agents, fan it out without the results collapsing into incoherence, and recognize that synthesis, not spawning, is where the real work lives.
AdvancedFrom One-Off to Repeatable Workflows
After this you can take a chat sequence that worked once and turn it into a workflow you can rerun, test, and debug — a deterministic structure that calls the model at fixed points instead of a fresh improvisation every time.
IntermediateMCP: The Universal Adapter
After this you can decide whether a given integration belongs on MCP at all, wire an existing server into a host without drowning it in tools, and recognize when a tutorial you are following is teaching a transport that no longer exists.
IntermediateRAG & Knowledge Access
After this you can decide how a model gets the knowledge a task needs — load it into the window, retrieve it on demand, or bake it into the weights — and you can tell when a confident answer is actually sitting on bad retrieval rather than on the facts you meant it to use.
IntermediateThe Token Economy: Cost as a Design Constraint
After this you can treat cost as a design constraint that shapes the system from the first decision, not a bill that arrives later.
IntermediateAutomation and Its Triggers
After this you can decide which steps of a workflow fire on a trigger without you watching, and which keep a human checkpoint, then structure the automated ones so a retry can never double-act.
IntermediateTrust Boundaries: Prompt Injection and the Hostile Context Window
After this you can look at any agent you have wired up to tools and data, decide whether it sits in the danger zone, and gate it before it can be turned against you.
AdvancedEvaluation and Verification: You Own Correctness
After this you can prove an AI system is right instead of trusting that it looks right.
IntermediateWriting and Content Without the Slop
After this you can put your own thesis, voice, and load-bearing facts into the prompt *before* the model writes, so the draft comes back distinctive instead of generic, and you stop spending your editing time injecting the specifics the model was never going to invent.
IntermediateData and Analysis You Can Trust
After this you can get analysis out of a model that you would actually stake a decision on, by making it compute answers in a checkable way instead of writing prose that merely looks like analysis, and by checking the assumptions underneath the math rather than the math itself.
IntermediateCoding With AI Agents: Stay the Verifier-in-Chief
After this you can hand real coding work to an agent and keep the leverage, because you have a way to verify what comes back.
AdvancedResearch and Synthesis at Scale
After this you can run a multi-source research pass that scales without rotting.
AdvancedExternalize State: The Source-of-Truth Discipline
After this you can run an AI agent across resets without losing the thread.
AdvancedBuild Primitives, Not Prompts
After this you can tell when a piece of AI work has earned the right to become a reusable primitive, and how to build it so it carries its own guarantees.
AdvancedConcurrency Discipline: Single-Writer and Reconciliation
After this you can run several agents at once without them corrupting shared state.
AdvancedParallel Extraction and Dedicated Synthesis
After this you can take a job that spans many sources and run it as one agent per source in parallel, each returning a compact summary, with a separate step that does nothing but reconcile those summaries.
AdvancedBuild the Improvement Loop Into the System
After this you can turn corrections into something the system keeps, instead of fixing the same mistake forever.
Advanced