0 of 32 done
Start hereThe AI engineer role

The applied-LLM path: building products on top of pre-trained models (mostly LLMs) via APIs — prompting, retrieval, tools, agents — without training models yourself. This is the deep-built track in the domain, and the one that maps to real applied-AI work (AI SDK, MCP, agents). Part of the AI/ML course — see it for how this differs from the Data Scientist and ML Engineer paths.

Built by cross-referencing the roadmap.sh ai-engineer roadmap and folding in the old 01-fundamentals/ notes (nothing dropped). The applied files (calling models, tools/MCP) are genuinely grounded in project work; the rest is a mix of grounded and reference.

Reading order

The track is in two parts. Part I (1–10) is the core path — everything you need to build an AI feature end to end. Part II (11–17) goes deeper on the topics that separate a demo from a shipped product: the reliable-component techniques, the production plumbing, and the depth topics (fine-tuning, self-hosting, voice). Read Part I in order; dip into Part II as you need it.

Part I — Building

  1. The AI Engineer Role — [Beginner] — AI engineer vs ML engineer, the “build on pre-trained models” paradigm, and the choose-the-right-tool decision process
  2. How LLMs Work — [Beginner → Intermediate] — tokens, context windows, transformers/attention, autoregression, and the sampling knobs (temperature, top-p/k, penalties) you set on every call
  3. The Model Landscape — [Beginner] — kinds of models, the LLM provider ecosystem, open vs closed/self-hosting, and the AI-tools categories
  4. Calling Models — [Intermediate] — provider APIs, the messages format, SDKs (streaming, structured output, tool calling), and the discipline of a fast-moving toolchain
  5. Prompt Engineering — [Beginner → Intermediate] — system/user/roles, zero/few-shot, chain-of-thought, structured output, and context engineering
  6. RAG & Embeddings — [Intermediate → Advanced] — embeddings, semantic search, the RAG pipeline, vector databases, and RAG vs fine-tuning
  7. Tools & MCP — [Intermediate] — function/tool calling and the Model Context Protocol (servers, clients, hosts)
  8. Agents — [Advanced] — the agentic (ReAct) loop, memory, multi-agent systems, frameworks, and observability
  9. Multimodal AI — [Intermediate] — vision input, image generation, speech (STT/TTS), and video
  10. Safety & Production — [Advanced] — prompt injection, guardrails, evals, cost, observability — turning a demo into a shipped product

Part II — Depth & Production

  1. Structured Output — [Intermediate] — JSON mode, schema-constrained decoding, and the discipline that turns an LLM into a reliable function
  2. Evals — [Intermediate → Advanced] — the core applied-AI skill: golden datasets, LLM-as-judge (and its biases), offline gates vs online signal, evaluating RAG and agents
  3. Reliability & Plumbing — [Intermediate] — retries/backoff, timeouts, rate limits, fallbacks, and AI gateways: making a flaky network call dependable
  4. Cost, Caching & Latency — [Intermediate] — model routing/cascading, prompt caching (freeze the front), streaming for perceived latency, trimming tokens
  5. Fine-Tuning (Applied) — [Advanced] — when (rarely) to fine-tune, LoRA/PEFT, SFT vs DPO, the dataset-is-the-project reality
  6. Local & Open Models — [Intermediate] — Ollama/vLLM, quantization (GGUF/AWQ), and when self-hosting an open model beats an API
  7. Voice & Realtime — [Advanced] — STT→LLM→TTS pipelines vs speech-native models, and the sub-second-latency constraint (streaming, turn-taking, barge-in)

Part III — Reps

Reading this track isn’t reps. The reps are building, so the builds are now in the folder rather than left as an exhortation:

  1. Lab Setup — [Beginner] — the environment the exercises assume: one key with a spending cap, a cheap model, usage printed on every call, and the habit of checking the SDK’s version-matched docs instead of your memory
  2. Practice Exercises — [Beginner → Advanced] — fifteen exercises over the whole track, each naming the note it exercises and what “done” looks like. The load-bearing four: build an eval set, build a RAG over your own notes, diagnose its failures as retrieval vs generation, and prompt-inject it
  3. Solutions — [Beginner → Advanced] — worked answers with code, and the reasoning behind each

Same pattern as ethical hacking and the RHCSA track: lab, exercises, solutions. The applied work you already do (AI SDK, MCP) is where this becomes real; these notes are the map, and Part III is the terrain.

  • Using AI — the prior course for non-programmers: using LLMs as a user. Note 1 below assumes you’ve either read it or absorbed it by osmosis
  • AI/ML course map — the three paths
  • Foundations — what a model is, and the (light) math this path needs
  • ai-automation/ — the no-code angle on applied AI
↑ Back to AI & ML