Welcome to AI Engineering
On this page
Most AI engineering interview prep is a pile of links: a transformer explainer here, a RAG tutorial there, a list of questions with one-line answers. It leaves gaps exactly where interviews probe: what this costs, how you'd measure it, what breaks in production. This track is one connected path from how a language model works to building, running and debugging real LLM systems, with every article written for the interview conversation.
What this track covers

- Start Here: this page, and What AI Engineering Interviews Test: the three roles behind the title and the usual rounds.
- LLM Foundations: tokens, attention, sampling, context and cost, embeddings, RoPE, how chat models are trained, hallucination, model choice, multimodal. Start with Tokens and Tokenization.
- AI Applications: building features on LLMs: prompting, structured output, streaming, memory, vector search, RAG, evals, guardrails, caching, rate limits. Start with Prompt Engineering for Production.
- Agents: tool calling, agent patterns, tool design, MCP, memory, multi-agent systems, reliability, evaluation, safety, computer use. Start with Tool Calling and the Agent Loop.
- AI Infra: what runs underneath: inference (KV cache, batching, quantization, speculative decoding), training at scale, GPUs and clusters, data pipelines, and LLMOps. Start with Prefill, Decode and the KV Cache.
- Fine-tuning: when to fine-tune at all, LoRA and QLoRA, SFT, RLHF and DPO, distillation, and evaluating the result. Start with Fine-tune, RAG or Prompt?.
- Practice: practical questions asked in interviews ("How would you cut LLM cost by 10x?") with weak, good and strong answers, and ML coding problems (attention, sampling, BPE, KV cache, RoPE, LoRA, an agent loop and more) in tested Python.
- Before Interview: a cheat sheet and the numbers every AI engineer should know.
Whole-product designs, such as designing ChatGPT, Perplexity or an enterprise RAG assistant, are in the AI System Design track. Articles here link to them where they apply.
Pick a path

You don't need to read every article. Pick the role you are interviewing for (the job description usually makes it clear) and follow its path; the articles are tagged with the paths they belong to.
- AI Application Engineer: Foundations → all of AI Applications → tool calling → KV cache and prefix caching basics → document ingestion and LLMOps → fine-tune vs RAG, LoRA, distillation → Practice: hallucinations, RAG debugging, latency, cost, prompt rollout, plus attention, sampling, retrieval and chunking code.
- Agent Engineer: core Foundations → prompting, structured output, memory, RAG, evals and guardrails → all of Agents → observability → Practice: hallucinations, the looping agent, prompt rollout, and the agent loop in code.
- AI Infra Engineer: Foundations including RoPE → streaming, vector search, caching and rate limits → all of AI Infra → Fine-tuning → Practice: latency, cost, sizing GPUs for a 70B model, a training loss spike, and all ML coding problems.
How each article is built
- Concept articles open with a problem, then explain how it works with pictures, the trade-offs and costs, what changes in production, a worked example, common mistakes, a short answer to say in the interview, and likely interview questions.
- Practical questions start from the question as an interviewer would ask it, explain why the problem happens, and compare weak, good and strong answers, with how to measure the result and follow-up questions.
- ML coding problems follow the coding interview format: problem, questions to ask, a nudge to try it yourself, an approach ladder, a tested Python solution, complexity, the common bug, and variants.
How to study
- Two weeks out: follow your path in order; for each concept, say the "Say this in the interview" answer out loud in your own words.
- One week out: do the Practice questions for your path without reading the answer first, then compare. Write the ML coding solutions from scratch and run them.
- The day before: read the cheat sheet and the numbers page, and rehearse two or three stories from your own work with numbers, evals and failures.
Say this in the interview
"When I design an LLM feature, I think about four things: what it costs in tokens and latency, how I'll measure quality before and after a change, how it fails, and what I'd trade off to fix it."
This sentence is the thread through the whole track. Every article teaches one piece of it.