Roadmap · 12 months

The AI Engineer Technical Path

A 5-stage path from Python and ML foundations to RAG, agents, and production — the canonical technical roadmap.

Core path12 months5 stages
On this page

This is the canonical technical path for becoming an AI engineer who builds with LLMs. It is not the path for training foundation models — that requires a PhD and large compute. This path is accessible to any CS student or software engineer willing to build real things.

Weeks 1–4

Python + Git + HTTP

  • Python fluency: data structures, comprehensions, async basics, virtualenvs, and reading tracebacks without panic.
  • Git for real work: branches, commits, pull requests, resolving conflicts.
  • HTTP and REST APIs: requests/responses, status codes, JSON, authentication headers.
  • Environment setup: a working editor, .env handling, and a repeatable project scaffold you can spin up in minutes.

Weeks 5–10

ML + LLM Foundations

  • How models actually work: training vs inference, parameters, the difference between an LLM and classic ML.
  • Prompting fundamentals: system vs user roles, few-shot, structured output, why prompts are unreliable.
  • Tokenization: tokens vs words, context windows, why long inputs cost more and truncate.
  • Embeddings: what a vector is, semantic similarity, when embeddings beat keyword search.
  • Calling LLM APIs: streaming, temperature, max tokens, cost per call, handling rate limits.

Weeks 11–18

RAG End-to-End

  • Chunking strategies: fixed-size, semantic, overlap, and why naive chunking ruins retrieval.
  • Vector search: storing embeddings (pgvector or Qdrant), top-k retrieval, metadata filtering.
  • Retrieval orchestration: query rewriting, hybrid search, re-ranking when top-k isn't enough.
  • Evaluation: building a golden question set, measuring retrieval hit rate and answer faithfulness.
  • Production RAG: caching, freshness, handling "I don't know," and keeping the index in sync with source data.

Weeks 19–26

Agents + Tools + Memory

  • The agent loop: plan, act, observe, repeat — and when an agent is overkill versus a single call.
  • Tool use: defining tools, parsing tool calls, executing them safely, returning results to the model.
  • MCP: connecting agents to external tools and data sources through a standard protocol.
  • Memory: short-term conversation state vs long-term stored memory, and when each matters.
  • Guardrails: input validation, output filtering, loop limits, and graceful failure.

Weeks 27–34

Production + Portfolio

  • Deployment: containerize the app, deploy a Python backend (FastAPI), serve streaming responses.
  • Observability: trace every LLM call, log prompts and outputs, surface latency and errors.
  • Cost control: token budgeting, caching, model routing (cheap model first, escalate when needed).
  • Ship one portfolio project end-to-end and write it up: the problem, the architecture, the trade-offs, and the results.

Skill priorities

Learn now

  • Python fluency
  • Git + building real projects
  • RAG fundamentals
  • Prompt engineering

Learn soon

  • Agent patterns + tool use
  • Evaluation and guardrails
  • FastAPI + deployment

Learn later

  • Fine-tuning and LoRA
  • Multi-agent systems
  • Custom model training

Ignore for now

  • Chasing every new framework
  • Leetcode-only prep
  • Tutorial marathons without building
  • "Learn everything" lists