Papers Reading Guide

The foundational and practical papers behind everything in this curriculum — with, for each: why it matters, what to read, what to skip on first pass, the production idea it influences, and the lab/phase connection. Read papers the way a senior engineer does: extract the idea and its production consequence, not every equation.

How to read an ML paper (the 3-pass method)

  1. Pass 1 (5 min): title, abstract, figures, conclusion. Answer: what problem, what idea, what result?
  2. Pass 2 (30 min): intro, method overview, results — skip heavy math/proofs. Answer: how does it work and why does it win?
  3. Pass 3 (deep): only for papers you'll implement — the math, ablations, appendices.

For interviews and production, Pass 2 is usually enough. The skill is knowing what production idea each paper unlocked — that's what this guide front-loads.

Tier 1 — The Foundations (read these first)

Attention Is All You Need (Vaswani et al., 2017)

  • URL: https://arxiv.org/abs/1706.03762
  • Why it matters: introduced the Transformer — the architecture under every modern LLM. Self-attention replaced recurrence, enabling parallel training and long-range context. This is the single most important paper to understand.
  • What to read: §3 (model architecture — attention, multi-head, positional encoding), Figure 1 (the diagram you should be able to redraw), §3.2 (scaled dot-product attention).
  • Skip on first pass: the exact training schedule, BLEU translation results, §6 details.
  • Production idea it influences: everything — attention is why context windows, KV-cache, and prefill/decode exist. The KV-cache (and its memory cost) is a direct consequence of attention.
  • Lab/phase connection: Phase 2 (transformer foundations); Phase 6.02 (KV-cache memory math); diagrams/01.

Language Models are Few-Shot Learners (GPT-3; Brown et al., 2020)

  • URL: https://arxiv.org/abs/2005.14165
  • Why it matters: showed that scale + in-context learning make a model do tasks from a few examples in the prompt — no fine-tuning. This is why prompting and few-shot are the first rungs of the adaptation ladder.
  • What to read: §1–§2 (in-context learning framing), the few-shot vs zero-shot results.
  • Skip on first pass: the exhaustive per-benchmark tables, broader-impacts appendix.
  • Production idea: the prompt→few-shot→RAG→fine-tune ladder (Phase 13.00) — try prompting/few-shot before training.
  • Lab/phase connection: Phase 1 (vocabulary), Phase 13.00.

Tier 2 — Serving & Efficiency (the production-systems papers)

Efficient Memory Management for LLM Serving with PagedAttention (vLLM; Kwon et al., 2023)

  • URL: https://arxiv.org/abs/2309.06180
  • Why it matters: the KV-cache wastes huge memory via fragmentation; PagedAttention manages it like OS virtual memory (pages), enabling far higher throughput and continuous batching. This is why vLLM is the default serving engine.
  • What to read: §3 (the fragmentation problem + paging solution), the throughput results.
  • Skip on first pass: the CUDA kernel details, scheduler internals.
  • Production idea: PagedAttention + continuous batching — the core of modern high-throughput serving and why GPU utilization went up.
  • Lab/phase connection: Phase 7.01 (vLLM), Phase 7.03–7.04; labs/lab-07-vllm-serving; diagrams/02.

Speculative Decoding (Leviathan et al., 2023 / Chen et al., 2023)

  • URLs: https://arxiv.org/abs/2211.17192 · https://arxiv.org/abs/2302.01318
  • Why it matters: decode is sequential and slow; a small draft model proposes several tokens that the big model verifies in parallel — same output distribution, fewer big-model steps → lower latency.
  • What to read: the core algorithm (draft → verify → accept/reject) and the speedup intuition.
  • Skip on first pass: the acceptance-probability proofs.
  • Production idea: speculative decoding / MTP for latency reduction without quality loss (Phase 6.07).
  • Lab/phase connection: Phase 6.07; diagrams/01.

Mixture-of-Experts (Switch Transformer; Fedus et al. / GShard, 2021)

  • URL: https://arxiv.org/abs/2101.03961
  • Why it matters: MoE routes each token to a few "expert" sub-networks, so total parameters grow without proportional compute per token — why some huge models are cheap to run. Explains "active vs total params" in model cards.
  • What to read: the routing idea, sparse activation, the params-vs-FLOPs decoupling.
  • Skip on first pass: load-balancing loss derivations, TPU specifics.
  • Production idea: reading active vs total parameters in model cards, and the memory/throughput implications (Phase 3, Phase 6).
  • Lab/phase connection: Phase 2, Phase 3.

Tier 3 — Adaptation & Fine-Tuning

LoRA: Low-Rank Adaptation of Large Language Models (Hu et al., 2021)

  • URL: https://arxiv.org/abs/2106.09685
  • Why it matters: fine-tune by training a tiny low-rank adapter while freezing the base — <1% of params, swappable, far cheaper. The production default for fine-tuning.
  • What to read: the low-rank update idea (ΔW = A·B), rank/alpha, which modules to adapt.
  • Skip on first pass: the intrinsic-dimension theory, GLUE tables.
  • Production idea: LoRA fine-tuning + swappable adapters (multi-LoRA serving) (Phase 13.02, Phase 13.07).
  • Lab/phase connection: Phase 13.02; labs/lab-13-lora-finetune.

QLoRA: Efficient Finetuning of Quantized LLMs (Dettmers et al., 2023)

  • URL: https://arxiv.org/abs/2305.14314
  • Why it matters: LoRA on a 4-bit quantized frozen base → fine-tune a 70B on a single GPU. Made fine-tuning accessible.
  • What to read: the 4-bit NF4 quantization + paged optimizers idea; the "quantize the frozen base cheaply" insight.
  • Skip on first pass: the quantile-quantization math, full ablations.
  • Production idea: QLoRA — the most VRAM-efficient fine-tuning (Phase 13.02, Phase 6.06 quantization).
  • Lab/phase connection: Phase 13.02; labs/lab-13-lora-finetune.

Training Language Models to Follow Instructions with Human Feedback (InstructGPT/RLHF; Ouyang et al., 2022)

  • URL: https://arxiv.org/abs/2203.02155
  • Why it matters: the SFT → reward model → RL (PPO) pipeline that made models helpful/aligned — the recipe behind ChatGPT.
  • What to read: the three-step pipeline (Figure 2), why preference data beats pure SFT.
  • Skip on first pass: PPO hyperparameters, full human-eval tables.
  • Production idea: the alignment pipeline and why instruct/chat models behave as they do (Phase 13.03).
  • Lab/phase connection: Phase 13.03.

Direct Preference Optimization (DPO; Rafailov et al., 2023)

  • URL: https://arxiv.org/abs/2305.18290
  • Why it matters: achieves RLHF's preference alignment without a reward model or RL — a simple loss on (chosen, rejected) pairs. The practical default for preference tuning.
  • What to read: the objective and the "no RL needed" insight; (chosen ≻ rejected) framing.
  • Skip on first pass: the derivation from the RLHF objective.
  • Production idea: DPO for preference tuning on a budget (Phase 13.03).
  • Lab/phase connection: Phase 13.03.

Constitutional AI / RLAIF (Bai et al., 2022)

  • URL: https://arxiv.org/abs/2212.08073
  • Why it matters: uses AI feedback (a model judging against principles) to scale alignment/safety labeling — the basis of RLAIF and a key safety technique.
  • What to read: the self-critique + AI-feedback loop; the "constitution" idea.
  • Skip on first pass: the specific principle list, red-team details.
  • Production idea: AI feedback for preference/safety data (with LLM-judge caveats) (Phase 13.05, Phase 12.02).
  • Lab/phase connection: Phase 12.02, Phase 13.03.

Distilling the Knowledge in a Neural Network (Hinton et al., 2015)

  • URL: https://arxiv.org/abs/1503.02531
  • Why it matters: the origin of knowledge distillation — a small student learns from a big teacher's soft outputs. The conceptual root of cheap/fast production models.
  • What to read: the soft-label/temperature idea (richer signal than hard labels).
  • Skip on first pass: the MNIST/speech specifics.
  • Production idea: distillation to cut cost/latency (incl. data/hard-label distillation = SFT on teacher outputs) (Phase 13.04).
  • Lab/phase connection: Phase 13.04.

Tier 4 — RAG, Agents & Tools

Retrieval-Augmented Generation for Knowledge-Intensive NLP (Lewis et al., 2020)

  • URL: https://arxiv.org/abs/2005.11401
  • Why it matters: the original RAG — combine a retriever with a generator so the model answers from retrieved documents. The foundation of giving LLMs current/proprietary knowledge.
  • What to read: the retriever+generator architecture, why retrieval beats parametric memory for facts.
  • Skip on first pass: the DPR training details, NQ/TriviaQA tables.
  • Production idea: RAG for knowledge (vs fine-tuning for behavior) — the core of Phase 9.
  • Lab/phase connection: Phase 9; labs/lab-03-rag-pipeline, labs/lab-09-hybrid-search; diagrams/03.

Dense Passage Retrieval (Karpukhin et al., 2020)

  • URL: https://arxiv.org/abs/2004.04906
  • Why it matters: showed dense (embedding) retrieval beats sparse keyword search for many tasks — the basis of vector-DB retrieval.
  • What to read: the dual-encoder idea, why embeddings capture semantic similarity.
  • Skip on first pass: the negative-sampling specifics.
  • Production idea: embeddings + vector DBs + hybrid (dense+sparse) search (Phase 9.03–9.05).
  • Lab/phase connection: Phase 9.03–9.05; labs/lab-09-hybrid-search.

ReAct: Synergizing Reasoning and Acting (Yao et al., 2022)

  • URL: https://arxiv.org/abs/2210.03629
  • Why it matters: interleaves reasoning (thought) and acting (tool calls) — the conceptual basis of the agent loop.
  • What to read: the thought→action→observation loop.
  • Skip on first pass: the per-benchmark prompts.
  • Production idea: the agent loop and planner-executor patterns (Phase 10.00, Phase 10.03).
  • Lab/phase connection: Phase 10; labs/lab-04-agent-tool-calling; diagrams/03.

Toolformer: Language Models Can Teach Themselves to Use Tools (Schick et al., 2023)

Lost in the Middle (Liu et al., 2023)

  • URL: https://arxiv.org/abs/2307.03172
  • Why it matters: models attend less to the middle of long contexts — so where you place retrieved chunks matters. Directly shapes context packing.
  • What to read: the U-shaped performance curve.
  • Skip on first pass: the per-model breakdowns.
  • Production idea: context packing / chunk ordering in RAG (Phase 9.07).
  • Lab/phase connection: Phase 9.07.

Tier 5 — Prompting, Reasoning & Evaluation

Chain-of-Thought Prompting (Wei et al., 2022)

  • URL: https://arxiv.org/abs/2201.11903
  • Why it matters: "let's think step by step" — prompting the model to reason before answering dramatically improves hard tasks. Underpins reasoning models and prompt design.
  • What to read: the CoT examples and the reasoning-vs-answer distinction.
  • Skip on first pass: the per-benchmark scaling curves.
  • Production idea: reasoning prompts, reasoning models, and reasoning distillation (Phase 1, Phase 13.04).
  • Lab/phase connection: Phase 1, Phase 5.

Holistic Evaluation of Language Models (HELM; Liang et al., 2022) & the benchmark-contamination literature

  • URL: https://arxiv.org/abs/2211.09110
  • Why it matters: evaluation is multi-dimensional (accuracy, calibration, robustness, bias, cost) — no single "quality" number. Plus: public benchmarks leak into training (contamination), so your own golden set is the moat.
  • What to read: the multi-metric framing; the contamination discussion.
  • Skip on first pass: the full scenario matrix.
  • Production idea: evaluate your task not benchmarks; a metric per task; golden datasets (Phase 12).
  • Lab/phase connection: Phase 12.01; labs/lab-05-eval-harness.

Scaling Laws for Neural Language Models (Kaplan et al., 2020) & Chinchilla (Hoffmann et al., 2022)

  • URLs: https://arxiv.org/abs/2001.08361 · https://arxiv.org/abs/2203.15556
  • Why it matters: predict how loss improves with parameters/data/compute — and Chinchilla showed many models were under-trained (data matters as much as size). Explains why model sizes/trends move as they do.
  • What to read: the power-law relationships; Chinchilla's compute-optimal data/param ratio.
  • Skip on first pass: the fit derivations.
  • Production idea: reasoning about model size vs capability vs cost trends (Phase 4, Phase 5).
  • Lab/phase connection: Phase 4.

A 10-paper "interview core" (if you only read ten)

For most LLM-engineering interviews, deeply understanding these ten (Pass 2) covers ~90% of what you'll be asked to reason about:

  1. Attention Is All You Need — the architecture.
  2. GPT-3 (few-shot) — in-context learning / prompting.
  3. PagedAttention/vLLM — modern serving.
  4. Speculative decoding — latency.
  5. LoRA — efficient fine-tuning.
  6. QLoRA — fine-tuning on a budget.
  7. RAG — knowledge augmentation.
  8. ReAct — agents/tool use.
  9. InstructGPT/RLHF (+ DPO) — alignment.
  10. Chain-of-Thought — reasoning.

The senior move: for each paper, be able to say the one production decision it changed. "PagedAttention is why we can run continuous batching and hit high GPU utilization." "LoRA is why we can serve 50 customer fine-tunes off one base." That framing — paper → production consequence — is what makes you sound like an engineer who builds, not one who only reads.

Related: References Overview · What Happens When You Prompt an LLM Agent · the per-phase Deep Readings tables cite these papers in context · interview-prep/ drills you on them.