Skip to content

The Researcher Path

In one line: A route for people who want to understand AI research itself - how to read papers, which papers to read in what order, how to reproduce results, and how to find open questions - built on this site's paper summaries and the reading roadmap. Last reviewed: 2026-10-21

The short version

  • Research literacy is a skill you can learn without a PhD: read a paper for its claim, its evidence, and its limits, in that order.
  • This site's paper summaries are the spine of the path. docs/ROADMAP.md gives paper-by-paper reading orders; this page tells you how to use them and what to do alongside them.
  • Read in threads, not by date: follow one idea (attention, scaling, alignment, reasoning, retrieval, diffusion) from its origin to today. Each thread takes one to three weeks.
  • Reproduce something. Re-running even a small result teaches you more about a paper than reading it five times.
  • The frontier is mostly in the open questions: what models actually compute inside, why they generalise, how far scaling goes, and how to evaluate systems smarter than the test.

Who this is for

Students considering research, engineers who want to read papers fluently, analysts who need to judge claims about AI, and anyone curious enough to want the primary sources. You should have done Phases 0 and 1 of the Zero to Hero path. For the deeper threads, Stages 1 and 3 of the ML engineer path (applied maths and deep learning) will help a lot.

How to read a paper

Most people read papers front to back and stall in the method section. Read in passes instead.

Pass 1 (10 minutes): title, abstract, figures, the conclusion, and the headings. Write one sentence: "This paper claims that X, shown by Y." If you cannot write it, read the abstract again.

Pass 2 (1 hour): introduction, the method at the level of "what goes in, what comes out, what is trained", the main results table, and the limitations section. Ask: what is the baseline, what is the metric, and is the gain larger than the noise?

Pass 3 (as needed): the details, the appendix, the code. Do this only for papers you will build on or try to reproduce.

The summaries on this site are written as a structured Pass 2: each one says why the paper matters, explains the core idea in plain language, walks through the components, and lists limitations and what came next. A good way to work is to read the summary first, then the paper's abstract and main results table, then decide whether to go deeper. Every summary links to the original.

Questions to ask of any result:

  • Compared to what? A big improvement over a weak baseline is a small result.
  • Measured how? Benchmarks leak into training data and saturate. The contamination and saturation explainer shows how this happens.
  • At what cost? A method that needs ten times the compute for a 2% gain may not matter.
  • Does it replicate? Has anyone else reproduced it, or built on it successfully?

The core threads

docs/ROADMAP.md has full paper-by-paper sequences (its "ML Student/Researcher" and "Reasoning and Agents" paths are the ones built for this page). docs/READING_GUIDE.md separates papers that matter historically from ones that matter for current practice. Here is the shape of each thread, with its entry points.

1. Architectures. From recurrent models to attention to the transformer, and the search for what comes after. Start at seq2seq and Bahdanau attention, then Attention Is All You Need, then the efficiency line (FlashAttention, GQA, multi-head latent attention, mixture of experts) and the alternatives (Mamba, Mamba-3).

2. Scaling and data. Why bigger worked, and its limits. Scaling laws, Chinchilla, emergent abilities (and the critique), FineWeb, model collapse, with the essays The Bitter Lesson and The Scaling Hypothesis. Then scaling limits and synthetic data and model collapse.

3. Alignment and post-training. How a next-token predictor becomes a helpful assistant. Deep RL from human preferences, learning to summarize from human feedback, InstructGPT, Constitutional AI, DPO, weak-to-strong generalization.

4. Reasoning. From prompting tricks to trained reasoning. Chain-of-thought, self-consistency, STaR, process reward models, OpenAI o1, DeepSeek-R1, test-time compute, s1. Pair with do LLMs reason?.

5. Agents. ReAct, Toolformer, Voyager, generative agents, SWE-bench, OSWorld, METR time horizons.

6. Generative media. VAE, GANs, DDPM, latent diffusion, flow matching, DiT and Sora. Diffusion models is the plain-English entry.

7. Interpretability and safety. What is going on inside, and what could go wrong. Induction heads, sparse autoencoders, circuit tracing, reasoning models don't always say what they think, sleeper agents, emergent misalignment, adversarial attacks, and frontier safety frameworks.

8. Science and the wider field. AlphaFold, AlphaZero, AlphaEvolve, robotics (RT-2, pi0), and world models (DreamerV3, Genie).

Browse everything by tag in TAGS.md or by category in INDEX.md.

Reproduce something

Reading tells you what a paper says. Reproducing tells you whether you understood it. Good first targets, roughly in increasing difficulty:

  1. Train a tiny GPT on a small text corpus and plot loss against model size for three sizes. You have just seen a scaling curve.
  2. Implement LoRA by hand on a small model and compare it with full fine-tuning.
  3. Re-run self-consistency on a small maths benchmark with an open-weight model: sample five answers, take the majority, and measure the gain over one answer.
  4. Train a small diffusion model on a simple image dataset following DDPM.
  5. Measure the real usable context of a local model with a needle-in-a-haystack test, then compare with RULER.

Keep a lab notebook: what you ran, the exact settings, the result, and what surprised you. Negative and partial results are still results.

Find open questions

Every summary on this site ends with limitations and what came next; those sections are a ready-made list of open problems. The open questions explainers cover the biggest debates (do LLMs reason, scaling limits, synthetic data). docs/GAPS.md lists papers this collection has not yet covered, which is a good place to look for something to summarise yourself.

To stay current, follow arXiv's cs.CL, cs.LG and cs.AI listings, and read lab technical reports critically. A technical report from a company is not peer-reviewed and often omits the details that would let you check it; the model family explainers track how disclosure has changed.

Common mistakes

  • Reading only the newest papers. New papers assume the old ones. Follow a thread from its origin.
  • Taking the abstract at its word. Abstracts sell. The results tables and limitations section tell you what was actually shown.
  • Treating benchmark gains as capability gains. Check for contamination, saturation, and whether the comparison was fair.
  • Never writing code. You understand a method when you can implement it, not when you can paraphrase it.
  • Working alone. Reading groups, open-source projects and public write-ups get you feedback that solitary reading never does.

Next steps

Sources

  • S. Keshav, "How to Read a Paper" (the three-pass method), ACM SIGCOMM Computer Communication Review, 2007: https://web.stanford.edu/class/ee384m/Handouts/HowtoReadPaper.pdf
  • arXiv listings: https://arxiv.org/list/cs.CL/recent, https://arxiv.org/list/cs.LG/recent, https://arxiv.org/list/cs.AI/recent