Best Books and Courses for Learning LLM Training in 2026: From Sutton to Karpathy

Best Books and Courses for Learning LLM Training in 2026: From Sutton to Karpathy

If you want to actually understand how large language models work in 2026, the right reading list is short, deliberate, and a mix of textbooks, implementation walkthroughs, and free courses. This guide ranks the ten resources that punch above their weight, organized by where they slot into the training pipeline.

TL;DR: The Reading List in One Table

The textbooks (1, 2, 3) build the math and theory. The implementation books (4, 5, 6, 7) take you from theory to a working training pipeline. The free courses (8, 9, 10) give you a parallel video track and the most current frontier-lab perspective.

How to Choose: A Decision Tree

• You are new to ML and want to learn LLMs from scratch. Start with Karpathy’s Zero to Hero. Then read Jurafsky and Martin’s transformer and pretraining chapters. Then work through Raschka’s Build an LLM From Scratch.
• You have ML background and want to skill up on LLMs. Read Jurafsky and Martin’s chapters on attention, transformers, instruction tuning, and RLHF. Then read Huyen’s AI Engineering for the system design layer. Watch the latest CS25 cohort for frontier topics.
• You are training your own model. Raschka’s Build an LLM From Scratch is the cleanest walkthrough. The Hugging Face NLP and LLM Courses give you the production pipeline. Read the latest Megatron-LM, DeepSpeed, and Llama 4 technical reports for distributed training.
• You are fine-tuning a pretrained model. Tunstall, von Werra, and Wolf’s NLP with Transformers plus the Hugging Face TRL documentation. Add Sutton and Barto chapters 13 (policy gradients) and 17 (preference-based RL) for RLHF and DPO.
• You are deploying and evaluating a model. Huyen’s AI Engineering for the system design. The Future AGI ai-evaluation library for production evaluators. The Future AGI traceAI package for OTEL-compatible instrumentation.

The Ten Resources in Detail

1. Speech and Language Processing, 3rd edition draft (Jurafsky and Martin)

The single most current textbook on modern NLP and LLMs. The third edition draft has been updated continuously since 2019 and the 2026 draft includes chapters on agents, instruction tuning, RLHF, RAG, and evaluation that did not exist in any prior textbook. Free at web.stanford.edu/~jurafsky/slp3.

Read chapters 9 (transformers), 10 (large language models), 11 (prompting and few-shot), 12 (fine-tuning and instruction tuning), and the evaluation chapter end-to-end. The earlier chapters on classical NLP are useful but skippable if you are short on time.

2. Deep Learning (Goodfellow, Bengio, Courville)

The math and neural-network foundations. Published in 2016, so chapters 10 through 20 are dated for 2026, but chapters 1 through 9 on linear algebra, probability, optimization, and feedforward networks are still the cleanest treatment available. Free HTML at deeplearningbook.org.

Read it as a math reference, not cover to cover.

3. Reinforcement Learning: An Introduction, 2nd edition (Sutton and Barto)

The canonical RL textbook. RLHF, DPO, and preference tuning are all variants of the policy-gradient and value-function machinery that this book builds up from scratch. Free at incompleteideas.net/book/the-book-2nd.html.

The chapters that map most directly to RLHF are chapter 13 (policy gradient methods) and chapter 17 (frontiers, which covers preference-based RL).

4. Build a Large Language Model (From Scratch) (Sebastian Raschka, Manning 2024)

The closest book-length walkthrough of pretraining a GPT-style model end to end. Raschka builds a working transformer in PyTorch from tokenizer to inference, with companion code at github.com/rasbt/LLMs-from-scratch.

This is the book to work through with a laptop open. The model is small enough to train on a single GPU but the architecture and training loop are the same machinery that powers production systems.

5. AI Engineering (Chip Huyen, O’Reilly 2025)

System design for LLM-powered products. Huyen covers evaluation, fine-tuning, RAG, agents, deployment, and the operational realities of running LLMs in production. Pair with her earlier Designing Machine Learning Systems for the broader ML systems frame.

The evaluation chapter alone is worth the cover price.

6. Hands-On Large Language Models (Jay Alammar and Maarten Grootendorst, O’Reilly 2024)

Practitioner-focused, heavy on visualizations, covers prompting, fine-tuning, RAG, and evaluation in working code. Alammar’s earlier blog posts (The Illustrated Transformer, The Illustrated GPT-2) are the diagrams every LLM engineer has seen, and this book packages that same visual style into an end-to-end resource.

7. Natural Language Processing with Transformers (Tunstall, von Werra, Wolf, O’Reilly 2022)

By three Hugging Face authors. The fastest path from transformer architecture to production fine-tuning. The 2022 publication date means some of the model lineup is dated, but the patterns and the Hugging Face library APIs are still the canonical reference.

Pair with the current Hugging Face Transformers documentation and the TRL library docs for RLHF and DPO.

8. Andrej Karpathy’s Zero to Hero series

Free YouTube. The single best video course for building LLM intuition from first principles. Karpathy walks through neural networks, backpropagation, building micrograd, building makemore, then building a small GPT in PyTorch. The series is freely available at karpathy.ai with linked GitHub repos.

The Let’s build GPT video alone is the cleanest single-video explanation of how transformers actually work.

9. Stanford CS25: Transformers United

Stanford seminar series with rotating guest lectures from OpenAI, Anthropic, Google DeepMind, Meta, and academic labs. New cohorts run each year and the lectures are posted free on YouTube. The course page is at web.stanford.edu/class/cs25.

This is the best running source for frontier topics that do not yet have textbook coverage, scaling laws, mixture of experts, multimodal training, reasoning models, and so on.

10. Hugging Face NLP and LLM Courses

End-to-end practical pipeline coverage. The NLP Course covers tokenizers, datasets, training, and fine-tuning. The newer LLM Course extends into RLHF with TRL, agents, and deployment with Inference Endpoints. Free at huggingface.co/learn.

The TRL chapter is the cleanest free walkthrough of DPO and PPO for language models.

What to Read Alongside the Books: The Papers That Matter

Books cannot keep up with frontier research, so a working LLM engineer also reads papers. The minimum reading list for 2026 is:

• Attention Is All You Need (Vaswani et al. 2017): the transformer paper.
• GPT-3 (Brown et al. 2020): in-context learning and scaling.
• InstructGPT (Ouyang et al. 2022): the original RLHF recipe.
• DPO (Rafailov et al. 2023): direct preference optimization, the simpler alternative to PPO-RLHF.
• LIMA (Zhou et al. 2023): less is more for alignment.
• Llama 3 and Llama 4 technical reports (Meta): open-weights training at scale.
• Anthropic and OpenAI model cards: the most current public information on frontier models.

Bookmark arXiv cs.CL and Papers With Code and skim weekly.

Where Future AGI Fits In: Evaluation and Observability for What You Train

Once you have read the books, watched the courses, and trained or fine-tuned a model, the gap to production is evaluation and observability. That is where Future AGI sits in the stack.

• ai-evaluation (Apache 2.0, github.com/future-agi/ai-evaluation): one Python package for heuristic, model-based, and LLM-as-a-judge evaluators. The string-template form is the fastest entry point:

from fi.evals import evaluate

result = evaluate(
    "faithfulness",
    output="The SLA is 99.95% uptime.",
    context="Our SLA guarantees 99.95% uptime in the master agreement.",
)
print(result.score, result.reason)

For custom judges, the metrics module ships CustomLLMJudge:

from fi.evals.metrics import CustomLLMJudge
from fi.evals.llm import LiteLLMProvider

judge = CustomLLMJudge(
    name="answer_quality",
    grading_criteria="Score 1-5: is the answer accurate, complete, and concise?",
    model=LiteLLMProvider(model="gpt-4o-mini"),
)
score = judge.evaluate(output="The capital of France is Paris.")

• traceAI (Apache 2.0, github.com/future-agi/traceAI): OTEL-compatible instrumentation for OpenAI, Anthropic, Vertex, Bedrock, LangChain, LangGraph, LlamaIndex, and the OpenAI Agents SDK.

• Agent Command Center at /platform/monitor/command-center: BYOK gateway for routing, budgets, caching, and pre-call guardrails. Useful once your trained or fine-tuned model is in front of real users.

• fi.simulate: persona-driven agent simulation for stress-testing a trained agent against scripted scenarios before production.

• Cloud evaluators: turing_flash (about 1 to 2 seconds), turing_small (about 2 to 3 seconds), and turing_large (about 3 to 5 seconds), documented at docs.futureagi.com/docs/sdk/evals/cloud-evals.

None of this replaces the books. It is the layer you wire in once you have the model.

Further Reading and Primary Sources

• Speech and Language Processing, 3rd edition draft (Jurafsky and Martin)
• Deep Learning (Goodfellow, Bengio, Courville)
• Reinforcement Learning: An Introduction (Sutton and Barto, 2nd ed.)
• Build a Large Language Model (From Scratch), Raschka, GitHub code
• Karpathy Zero to Hero series
• Stanford CS25: Transformers United
• Hugging Face Learn (NLP and LLM Courses)
• Hugging Face Transformers documentation
• Hugging Face TRL library documentation
• arXiv cs.CL recent listings
• ai-evaluation GitHub repository
• traceAI GitHub repository
• Future AGI cloud evaluators documentation

Closing Thoughts

The right LLM reading list in 2026 is short. Three textbooks (Jurafsky, Goodfellow, Sutton), four implementation books (Raschka, Huyen, Alammar, Tunstall), and three free courses (Karpathy, CS25, Hugging Face). Read at least one from each cluster, then keep up with the technical reports and weekly arXiv listings.

The books teach you what to build. The evaluation and observability layer (Future AGI’s ai-evaluation, traceAI, Agent Command Center) is what you wire in once the model is real and users are using it.