There is a version of this review that is unfair, which treats a 2022 book as though it were trying and failing to be a 2026 one. I want to avoid that, because what this book set out to do it did better than anyone else, and the reason it feels dated is that the field moved rather than that the authors got anything wrong. The authorship is the starting point. Tunstall, von Werra and Wolf work at Hugging Face and built substantial parts of the tooling the book teaches.
That produces a specific quality you notice quickly. When they explain why a function behaves a particular way, or why an approach that seems reasonable will cause you problems, it is because they have handled the issues from people who tried it. Third party books about a library are always working from the outside, inferring intent from documentation. This one is written from inside, and the practical guidance is correspondingly sharper.
The technical core is the explanation of how transformers actually work, and it remains the best treatment I know at this level. The attention mechanism is built up carefully rather than presented as a diagram to be memorised. Queries, keys and values are motivated before they are named, multi head attention arrives as an answer to a limitation you have just been shown, and positional encoding appears because the architecture obviously needs it. The distinction between encoder, decoder and encoder decoder models is drawn clearly, which matters enormously and is fudged in most explanations.
Tokenisation gets a full chapter and deserves one, because a startling amount of confusing model behaviour is tokenisation behaviour, and most practitioners have only a vague sense of what subword algorithms do. The book is structured around tasks, which was the right call. Text classification, named entity recognition, question answering, summarisation, each as a chapter that takes you from a dataset to a fine tuned model that works. You finish each one with something running, and the cumulative effect is a real understanding of the fine tuning workflow rather than a theoretical one.
The efficiency chapter is the part that has aged best, and I would argue it is more relevant now than when it was written. Knowledge distillation, quantisation and pruning, explained properly with working examples. Everyone wants smaller and faster models now, inference cost is the line item people actually notice, and clear material on the techniques is still surprisingly rare. This chapter alone justifies keeping the book on a shelf.
Now the problem, which is not subtle. This book was written when the interesting question was how to fine tune a moderately sized encoder model on your own labelled data for a specific task. That was the right question in 2021. It is not the question most teams are asking now.
The generative era, instruction tuning, models that handle a task from a description rather than from examples, retrieval augmented generation, tool use and agents, the whole shift toward calling a large model through an API rather than training your own, all of that is either absent or gestured at. A reader coming to this book expecting to learn how to build with current language models will find themselves learning a workflow that, while still valid, is not the one their team is using. That gap is fundamental rather than fixable with an appendix. The revised edition updated things, and the update did not and could not change the book's underlying premise.
The library has also moved. Interfaces have been refactored, new abstractions have arrived, and some of the code patterns shown are no longer the idiomatic way to do the thing. The notebooks are maintained better than most, which softens this considerably, but you will occasionally be learning yesterday's approach in good faith. The prerequisites are real and understated.
This assumes you write PyTorch comfortably and understand neural network training. It is not a first deep learning book and readers who arrive without that background have a bad time, because the pace assumes you are only learning the transformer specific parts. The chapter on training at scale is the one I find least useful for most readers. It is well written and it describes work that requires compute the overwhelming majority of people do not have.
It reads as interesting rather than actionable, and that is a reasonable use of pages provided you know that going in. My 4.0 is a score for a very good book about a moment that has passed. If you want to understand what a transformer is doing, at the level where you could reason about a failure rather than just observe it, this is still the clearest path and the internals do not expire. If you want to know how to build a product on top of a large language model in 2026, read something else and come back to this when you want to know why the thing under you works.