This is the roadmap for learning agentic engineering from zero to shipping: a sequenced path that takes you from never having run a coding agent to building and deploying production software you direct and verify. Agentic engineering is the discipline of building real software by directing AI agents while you own the goal, the context and the quality, and it is learned by doing, stage by stage. Below is the exact order to go through it, mapped to the five courses of the campus and the deep-dive guides for each step, so you are never guessing what to learn next. Work top to bottom; each stage assumes the one before it. Everything here is current as of June 2026, and it pairs with our pillar, What Is Agentic Engineering.
How to use this roadmap
Do not try to learn everything at once. The fastest way to ruin the journey is to read about subagents and MCP before you have shipped a single thing. Go in order: get one app live, then deepen your command of the agent, then learn the production stack, then automation, then the quality and agent-first practices that make your work trustworthy. Each stage below names the course that teaches it and the guides that go deeper on the trickiest parts. Build something real at every stage rather than collecting tutorials, because the loop only clicks when you have felt it on your own project.
- Go in order; each stage builds on the last.
- Ship something real at every stage, not just read.
- Use the linked course for the path and the linked guides for the deep dives.
- Refer to the glossary whenever a term is new.
Stage 1: Foundations - ship your first app
Start here even if you have never opened a terminal. The Foundations course takes you from understanding how LLMs and coding agents actually work, through installing Claude Code and Codex, prompting them well, scaffolding a project, and shipping a real website to the public internet. By the end you have done the whole arc once: an idea becomes a deployed app. The companion guide here is How to Use Claude Code, which gets you productive in your first session, and the underlying model and harness vocabulary is in the glossary if you want the definitions.
- Course: Foundations - From Zero to Your First Shipped App.
- Guide: How to Use Claude Code (your first productive session).
- Outcome: one real website deployed to the internet, the full arc done once.
- Glossary: AI agent, agent harness, agentic AI.
Stage 2: Claude Code Mastery - direct the agent well
Once you can ship, deepen your command of the harness so the agent becomes a reliable teammate rather than a slot machine. The Claude Code Mastery course covers teaching it your rules with CLAUDE.md, packaging workflows as skills and commands, automating quality gates with hooks, connecting tools with MCP, running multi-agent workflows with subagents, and managing context without burning money. This is where the explore-plan-implement-verify loop becomes second nature. Lean on the Claude Code cluster of guides for each feature: subagents, hooks, skills and commands, and MCP setup.
- Course: Claude Code Mastery - Becoming a Power User.
- Guides: Claude Code Subagents, Hooks, Skills and Slash Commands, and MCP setup.
- Outcome: the explore-plan-implement-verify loop becomes a habit, not an effort.
- Glossary: subagent, system prompt, context window, prompt caching.
Stage 3: The Modern App Stack - build something real
Now build a product, not just a page. The Modern App Stack course wires up how real apps fit together: authentication and OAuth with Clerk, a reactive database with Convex, safe secret handling, payments with Stripe, and the migration from development to production. This is the stage where agentic engineering stops being a coding trick and becomes how you assemble a working SaaS. You direct the agent across a multi-service codebase while keeping the architecture clean enough that it (and you) can navigate it.
- Course: The Modern App Stack - Auth, Data and Payments.
- Outcome: a production-shaped app with auth, a database and payments.
- Skill focus: directing an agent across a real, multi-service codebase.
- Glossary: AI IDE, tool calling.
Stage 4: Automation and Agentic Systems - make it run itself
With a product under your belt, move from single tasks to systems. The Automation and Agentic Systems course compares n8n, Zapier and Trigger.dev, automates the browser with Playwright, runs code safely in sandboxes, builds your own AI tools on top of APIs, and designs human-in-the-loop systems with the right level of autonomy. This is where you build the workflows and tools that keep working when you step away, and where the five levels of LLM autonomy become a practical design choice rather than a concept.
- Course: Automation and Agentic Systems.
- Outcome: workflows and tools that run without you babysitting them.
- Skill focus: choosing the right autonomy level and keeping a human in the loop.
- Glossary: workflow automation, tool calling.
Stage 5: Quality, Security and Agent-First - ship it for real
The final stage makes your work production-grade and discoverable by both humans and AI. The Quality, Security and the Agent-First Business course covers tests and CI/CD, security and privacy, getting found through SEO and GEO/AEO, designing agent-first products whose APIs other agents love to use, and a capstone where you build and ship a complete agentic product end to end. Finish this and you are not learning agentic engineering any more; you are practising it. From here, keep shipping, and revisit the deep-dive guides whenever a project pushes you into new territory.
- Course: Quality, Security and the Agent-First Business.
- Outcome: a complete agentic product, shipped and findable by humans and AI.
- Skill focus: tests, security, GEO/AEO and agent-first API design.
- Glossary: GEO, AEO, llms.txt.
Step by step
Stage 1: ship your first app
Work through the Foundations course and the How to Use Claude Code guide. Goal: take one idea from nothing to a real website deployed on the public internet.
Stage 2: master the agent
Work through Claude Code Mastery and the Claude Code guides (subagents, hooks, skills and commands, MCP). Goal: make the explore-plan-implement-verify loop automatic.
Stage 3: build the modern app stack
Work through The Modern App Stack course. Goal: a production-shaped app with Clerk auth, a Convex database and Stripe payments, directed by the agent.
Stage 4: automate and build agentic systems
Work through Automation and Agentic Systems. Goal: workflows and tools that keep running on their own, with the right autonomy level and a human in the loop.
Stage 5: quality, security and agent-first
Work through Quality, Security and the Agent-First Business and ship the capstone. Goal: a complete, tested, secure, findable agentic product you built end to end.