← Back to reading

// 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.

  1. 01

    Attention Is All You Need

    Vaswani et al. · 2017 · ~3 harXiv:1706.03762PDF

    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

  2. 02

    Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks

    Lewis et al. · 2020 · ~2.5 harXiv:2005.11401PDF

    Problem

    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

  3. 03

    LoRA: Low-Rank Adaptation of Large Language Models

    Hu et al. · 2021 · ~2.5 harXiv:2106.09685PDF

    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

  4. 04

    Chain-of-Thought Prompting Elicits Reasoning in Large Language Models

    Wei et al. · 2022 · ~2.5 harXiv:2201.11903PDF

    Problem

    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

  5. 05

    Training Language Models to Follow Instructions with Human Feedback

    Ouyang et al. · 2022 · ~4 harXiv:2203.02155PDF

    Problem

    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

  6. 06

    ReAct: Synergizing Reasoning and Acting in Language Models

    Yao et al. · 2022 · ~2.5 harXiv:2210.03629PDF

    Problem

    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

  7. 07

    Toolformer: Language Models Can Teach Themselves to Use Tools

    Schick et al. · 2023 · ~2.5 harXiv:2302.04761PDF

    Problem

    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

  8. 08

    Direct Preference Optimization: Your Language Model is Secretly a Reward Model

    Rafailov et al. · 2023 · ~3 harXiv:2305.18290PDF

    Problem

    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

  9. 09

    Lost in the Middle: How Language Models Use Long Contexts

    Liu et al. · 2023 · ~2.5 harXiv:2307.03172PDF

    Problem

    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. 10

    Efficient Memory Management for Large Language Model Serving with PagedAttention

    Kwon et al. · 2023 · ~3 harXiv:2309.06180PDF

    Problem

    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.