←shelf// the path · 01 / 01
LIVE · CURRICULUM·AI ENGINEERING·2026·04 STAGES·32 LESSONS

if I were starting over,this is the pathI'd actually take.

Most roadmaps online are someone's wishlist. This is the order I'd do it in — boring fundamentals first, because shipping AI in production is 80% software, 20% prompts.

// 01 · the orderclick to open

Order matters.

Skip a stage and you'll spend months patching what should have been right at week one. Read it top to bottom.

Foundations.

stage 00·06 lessons
  1. 01

    Basics Frontend

    HTMLCSSJavascript

    The web's three primitives. Skip them and you're guessing for the next ten years.

  2. 02

    ReactJS

    JSXhooksstate

    The default for component-driven UI. Learn hooks, learn why your app re-renders too much, learn the lifecycle.

  3. 03

    NextJS

    App RouterRSCserver actions

    The default fullstack-React shape in 2026. App Router and server components are the part everyone gets wrong first.

  4. 04

    Backend

    RESTauthschemas

    One language, one framework. Take it past hello-world — auth, errors, schemas, a real deploy. Even if you're the only one hitting it.

  5. 05

    Python

    FastAPIFlask

    FastAPI is the right pick for AI work — async, typed, plays nicely with every LLM library you'll touch.

  6. 06

    NodeJS

    ExpressNestJS

    If your stack is JS-first, pick this. NestJS if you like structure, Express if you want raw.

Ship muscles.

stage 01·08 lessons
  1. 01

    Git & CI/CD

    GitHub Actionspreview deploys

    Every merge should deploy itself. If shipping takes a ritual, you'll ship less.

  2. 02

    Databases

    PostgresSQLmigrationsRedis

    Most AI products are a database with a model bolted on. Learn real SQL and migrations now — it pays off again in RAG.

  3. 03

    Cloud

    AWSGCPAzure

    Pick one. AWS still wins on services, GCP on AI primitives, Azure on enterprise. You only need one.

  4. 04

    Docker

    Containers are the unit of shipping. Learn this before Kubernetes lies to you about needing a cluster.

  5. 05

    Queues & background jobs

    workersretriesrate limits

    LLM calls are slow, flaky and rate-limited. Anything over a few seconds belongs in a worker with retries, not in a request handler.

  6. 06

    Auth & secrets

    sessionsOAuthenv vars

    Sessions, OAuth, and keeping API keys out of git. An LLM key in the wrong place is an invoice, not a bug.

  7. 07

    Monitoring & error tracking

    Sentrystructured logs

    Know it's broken before your user tells you. This is the plain-software version of the logs-at-2am advice, and it comes before LLM observability.

  8. 08

    Terraform

    optional

    Infrastructure as code. Click-ops doesn't scale, and neither does your sanity at 3am. Skip it until you're managing more than one environment.

AI fundamentals.

stage 02·08 lessons
  1. 01

    Pre-trained Models

    GPTSonnetGemini

    Three families. Pick one default, know each one's strengths. Don't ship a switching layer until a real customer asks for it.

  2. 02

    Prompt Engineering

    system promptsfew-shot

    Clear instructions, good examples, and knowing why a prompt fails. Unglamorous, and still the highest-leverage skill in the stage.

  3. 03

    Structured Outputs

    JSON schemaZodPydantic

    Make the model return data your code can trust. The difference between a demo and something you can build on.

  4. 04

    Tool Calling

    How a model asks your code to do something. Everything agentic — and MCP — is built on this one primitive.

  5. 05

    Embeddings

    Text as vectors, similarity as math. Small idea, and the foundation under search, RAG and memory.

  6. 06

    Streaming

    SSEpartial output

    Users judge AI products by time to first token. Stream everything, including tool calls and structured output.

  7. 07

    AI Agents

    LLMs in a loop with tools. Most aren't worth it yet — learn enough to know when they're not.

  8. 08

    MCP

    Anthropic's Model Context Protocol. The integration shape that matters in 2026 — adopt early or rebuild later.

The AI layer.

stage 03·10 lessons
  1. 01

    RAG

    vectorgraphSQLreranking

    Embed, retrieve, augment — the first thing every "AI app" actually is. Start with vector, reach for SQL when the data is structured (the boring one that ships), graph when relationships beat text similarity. Chunking, hybrid search and reranking are where demos turn into products.

  2. 02

    Agent Orchestration

    LangGraphCrew AI

    State machines for agents. Less magic, more control — LangGraph is currently the right shape for production agents. Multi-agent frameworks like Crew AI suit specific workflows and are oversold for everything else.

  3. 03

    LLM Observability

    tracescostlatency

    Trace every call: prompt, tools, tokens, cost, latency. You can't fix what you can't replay, and the traces become your eval data.

  4. 04

    Evals

    Tests for non-deterministic software. Start with ten real failures turned into cases, and run them on every prompt or model change.

  5. 05

    Guardrails

    prompt injectionPII

    Runtime safety, not quality scoring. Treat model input and output as untrusted — especially once the model has tools.

  6. 06

    Memory Layer

    What the system remembers across sessions — facts, preferences, past decisions — and what it's allowed to forget.

  7. 07

    Context Store

    Where context lives and how it's assembled for each call. The window is finite; what goes in it is the actual design problem.

  8. 08

    Multi-Modal AI

    Vision, voice, structured outputs from one model. Where the next batch of actually-useful products gets built.

  9. 09

    Inference

    cachingbatchingvLLMOllama

    Latency and cost at scale: prompt caching, batching, model routing, and when self-hosting actually beats an API. Fine-tuning belongs here too — mostly as knowing when not to.

  10. 10

    Harness building

    contextmemoryevalstool routing

    The capstone: wiring everything above into the infra layer between the model and your product — context management, memory, tool routing, retries, evals. Where the next two years of competitive advantage live, until one Anthropic release vaporizes the category. Worth learning to find out which.

// 02 · the takestrong opinions

Pick one,
finish it.

The trap is breadth. You'll be tempted to learn React and Vue, FastAPI and Express, AWS and GCP, LangGraph and Crew AI at the same time. Don't.

Pick one of each. Take it past hello-world — deploy it, hit the bugs that only show up in prod, fix them, watch your own logs at 2am. Even if you're the only user. You'll learn more from one deployed thing than from ten weekend tutorials.

“The next five years are either production-harness companies, or one Anthropic release that makes them all look like bloated wrappers. I'm betting on what I can control.”