// Reading Plan · Research Papers
The derivations behind the stack.
Ten papers, chronological, because the order is the argument: each answers a question the previous one left open. Read beside the stage they belong to, not after the whole plan.
10 papers · ~28 h · counted separately from the book total
The books summarise; these are the derivations. Each is read twice, once for the idea and once for the method. They sit alongside the sequence rather than after it, because the claim they check is usually met two stages in.
Problem
Sequence transduction meant recurrence or convolution plus attention: slow to train, and distant positions could only be related through a long chain of steps.
The move
Drop recurrence and convolution entirely. Self-attention over the whole sequence at once, so every position attends to every other in a single step.
For your work
The architecture under every model you call. Read it to see why context length costs quadratically, why position has to be injected rather than learned from order, and what the KV cache you serve actually is.
Pairs with Stage 2: AI & ML Engineering Core
- 02
Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks
Lewis et al. · 2020 · ~2.5 harXiv:2005.11401PDFProblem
A pre-trained model keeps its knowledge in its parameters, so updating a fact means retraining, and the model still cannot show where an answer came from.
The move
Pair a parametric sequence-to-sequence model with a non-parametric vector index over Wikipedia, and train the retriever and the generator end to end.
For your work
The paper behind the RAG you build. Retrieval and generation are one system rather than two, which is why the index is part of the model rather than a lookup in front of it.
Pairs with Stage 3: LLM Applications & Operations
Problem
Fine-tuning a large model updates every weight, which costs about the same memory and storage as the model itself.
The move
Freeze the pre-trained weights and inject trainable low-rank matrices into each layer, so the update is a pair of thin matrices rather than a full copy.
For your work
Why adapters work and where they fail. Read it before choosing between a fine-tune and RAG, and before assuming a small rank is always enough.
Pairs with Stage 3: LLM Applications & Operations
- 04
Chain-of-Thought Prompting Elicits Reasoning in Large Language Models
Wei et al. · 2022 · ~2.5 harXiv:2201.11903PDFProblem
Prompting for an answer directly fails on multi-step reasoning, and the model cannot show its work.
The move
Put a few chain-of-thought demonstrations in the prompt, so the model generates intermediate reasoning steps before it commits to an answer.
For your work
The mechanism behind structured-output and reasoning prompts. It also shows the limit: the steps are generated, not verified, so a confident wrong trace still reads as plausible.
Pairs with Stage 3: LLM Applications & Operations
- 05
Training Language Models to Follow Instructions with Human Feedback
Ouyang et al. · 2022 · ~4 harXiv:2203.02155PDFProblem
A model trained to predict text is not trained to follow instructions, and more capability makes misalignment worse rather than better.
The move
Supervised fine-tuning on demonstrations, then a reward model learned from human comparisons, then PPO against that reward.
For your work
The RLHF pipeline every aligned model descends from. Long, but it is where label quality, reward hacking, and the real cost of preference data become concrete.
Pairs with Stage 3: LLM Applications & Operations
- 06
ReAct: Synergizing Reasoning and Acting in Language Models
Yao et al. · 2022 · ~2.5 harXiv:2210.03629PDFProblem
Reasoning and acting were studied separately: a model could think without grounding, or act without a plan it could revise.
The move
Interleave reasoning traces with tool actions, so the trace induces and updates the plan while each action gathers information back into it.
For your work
The agent loop you already ship. Read it to see why the trace has to stay in the prompt, and why hallucination drops once the model can observe the result of its own call.
Pairs with Stage 3: LLM Applications & Operations
- 07
Toolformer: Language Models Can Teach Themselves to Use Tools
Schick et al. · 2023 · ~2.5 harXiv:2302.04761PDFProblem
A model can be told to use a tool in a prompt, but it does not know which call to make, when to make it, or with what arguments.
The move
Let the model insert candidate API calls into ordinary text, execute them, and keep only the calls whose result lowers the loss on the tokens that follow.
For your work
The self-supervised route to tool use, and the clearest statement of the tool-calling contract: a name, arguments, and a defined way for the result to re-enter the context.
Pairs with Stage 3: LLM Applications & Operations
- 08
Direct Preference Optimization: Your Language Model is Secretly a Reward Model
Rafailov et al. · 2023 · ~3 harXiv:2305.18290PDFProblem
RLHF needs a separate reward model and an RL loop, and both are unstable and expensive to run.
The move
Reframe preference optimisation as a classification loss on the policy itself, removing the reward model and the sampling loop.
For your work
The simpler alignment path now in most stacks. Read it to know what you gain in stability and what you may lose against a well-tuned reward model.
Pairs with Stage 3: LLM Applications & Operations
- 09
Lost in the Middle: How Language Models Use Long Contexts
Liu et al. · 2023 · ~2.5 harXiv:2307.03172PDFProblem
A long context was assumed to be a usable context, and no one had measured where in that context a model actually looks.
The move
Show that performance peaks when the answer sits at the start or the end of the context and drops sharply when it is buried in the middle, even with a longer window.
For your work
The empirical basis for context engineering: put the instruction and the key fact at the edges, re-rank so the relevant chunk lands early, and treat a longer window as a cost rather than a free upgrade.
Pairs with Stage 3: LLM Applications & Operations
- 10
Efficient Memory Management for Large Language Model Serving with PagedAttention
Kwon et al. · 2023 · ~3 harXiv:2309.06180PDFProblem
Serving wasted most of the GPU memory on KV cache fragmentation, so concurrency was bounded by memory rather than by compute.
The move
Treat the KV cache like virtual memory: fixed-size pages, a block table, and copy-on-write sharing of blocks across requests.
For your work
Why serving throughput is a memory-management problem. Read it before tuning batch size or buying a larger GPU.
Pairs with Stage 3: LLM Applications & Operations
// Where this fits
The books are the argument; these are the derivations. Read a paper when the stage it belongs to makes the claim checkable, rather than saving all ten for the end. The certificates are the credential layer on top, and the blog is where the reading turns into build notes.