AI Engineering: Building Applications with Foundation Models

by Chip Huyen

Recent breakthroughs in AI have not only increased demand for AI products, they've also lowered the barriers to entry for those who want to build AI products. The model-as-a-service approach has transformed AI from an esoteric discipline into a powerful development tool that anyone can use. Everyone, including those with minimal or no prior AI experience, can now leverage AI models to build applications. In this book, author Chip Huyen discusses AI the process of building applications with readily available foundation models.

The book starts with an overview of AI engineering, explaining how it differs from traditional ML engineering and discussing the new AI stack. The more AI is used, the more opportunities there are for catastrophic failures, and therefore, the more important evaluation becomes. This book discusses different approaches to evaluating open-ended models, including the rapidly growing AI-as-a-judge approach.

AI application developers will discover how to navigate the AI landscape, including models, datasets, evaluation benchmarks, and the seemingly infinite number of use cases and application patterns. You'll learn a framework for developing an AI application, starting with simple techniques and progressing toward more sophisticated methods, and discover how to efficiently deploy these applications.

Understand what AI engineering is and how it differs from traditional machine learning engineeringLearn the process for developing an AI application, the challenges at each step, and approaches to address themExplore various model adaptation techniques, including prompt engineering, RAG, fine-tuning, agents, and dataset engineering, and understand how and why they workExamine the bottlenecks for latency and cost when serving foundation models and learn how to overcome themChoose the right model, dataset, evaluation benchmarks, and metrics for your needsChip Huyen works to accelerate data analytics on GPUs at Voltron Data. Previously, she was with Snorkel AI and NVIDIA, founded an AI infrastructure startup, and taught Machine Learning Systems Design at Stanford. She's the author of the book Designing Machine Learning Systems, an Amazon bestseller in AI.

AI Engineering builds upon and is complementary to Designing Machine Learning Systems (O'Reilly).

Genres: Artificial Intelligence, Technology, Programming, Nonfiction, Software, Technical, Computer Science

875 pages, Kindle Edition

Published December 4, 2024

About the author

I’m Chip Huyen, a writer and computer scientist. I grew up chasing grasshoppers in a small rice-farming village in Vietnam.

I'm interested in AI for storytelling and roleplaying. Previously, I built machine learning tools at NVIDIA and Netflix. I've also founded and sold a company.

I graduated from Stanford, where I taught ML Systems. The lectures became the foundation for the book Designing Machine Learning Systems, which is an Amazon #1 bestseller in AI and has been translated into 10+ languages (very proud)!

My new book AI Engineering (2025) is currently the most read book on the O’Reilly platform. It’s also available on Amazon and Kindle.

In my free time, I travel and write. After high school, I went to Brunei for a 3-day vacation which turned into a 3-year trip through Asia, Africa, and South America. During my trip, I worked as a Bollywood extra, a casino hostess, and a street performer.

Reviews

[Sebastian Gebski]

Uff, I've finally managed to get this one through - and this was quite a journey.

Why did I reach for it? Based on recommendations of some knowledgeable people who called it a best book to upgrade your practical skills on building modern AI systems.

What did I expect? I call it a "Karpathy" level experience ;D Andrej is able to explain complex concepts in a way that still requires a lot of effort, but it reduces significantly the "steepness" of the learning curve.

Did I get it? Not really, but it doesn't mean it's a bad book:
- it doesn't assume much when it comes to your starting level (with Gen AI, LLMs), so you're taught concepts like finetuning, RAG or recall
- it indeed does not focus on a single aspect of using LLMs (e.g., prompting) - there are decent chapters on finetuning (even - very decent), quality assurance, inference optimisation, etc.
- sometimes very unevenly it jumps between pretty high and very deep level - I don't think the author is bragging, it's just that she was no sure who the book is for: the folks who just start with building simple things with AI, or the ones who know all the basics bits and pieces and now need to dive really deep
- it's clear that the author is very knowledgeable, I won't question that - but I missed a bit of "practical decision-making" when it comes to going beyond the basic arch (which is covered); that may be feel I'm not getting much beyond what is already freely available online in abundance

Good book, or even a very good one (4.3-4.5), but it didn't rock my world. Yes, there were some sub-chapters definitely beyond my level of knowledge (which I didn't follow straight to the very end), but still - I think I've expected (after the enthusiastic reviews) slightly "more". Maybe this more is more "focus" or more "practicability". And no, unfortunately it wasn't "Karpathy level" of explaining ;) But I'll definitely check out what that author releases next - this one was a good start.

[dantelk]

My profession is computer programming, and I wanted to read more on AI, both for my own pleasure, and since I didn't want to lag behind the competitors (other programmers).
Before starting this book, i tried two others, and DNF them.
- https://www.goodreads.com/book/show/2... this one made a too quick deep dive, and i felt that what I was reading didn't leave any foundation information in my memory.
- https://www.goodreads.com/book/show/1... I am not THAT nerd.

Although I am new to the field, and the book spreads into a wide range of topics, Chip's book was easy to follow, and was a good introduction for my level. I believe I should better re-read it after a year or so, when my overall AI knowledge is more advanced. If I was interviewed about the topics discusses in the book today, probably I wouldn't be able to utter more than a few words, but still, I felt that the book laid good foundation information, and gave me insight about what to focus on the following levels of my AI education.

There are at least two other goodreads friends of mine who read this book simultaneously, and I am very curious about their own impressions too! :) I guess people with more advanced AI knowledge my find the book a bit high level.

[Ali]

Broad survey of building blocks for developing AI apps. Huyen delivers a readable however meandering review of popular models and design patterns. It gets too much into weeds for beginners while lacking the in depth architectural analysis for seasoned folks. It certainly fills a niche for adaptation of existing models with fine tuning, data curation and prompt engineering.

[Jacob]

Light, breezy read. Perfect for a beach trip or unwinding before bed.

Honestly there was more information packed into this book than almost anything I’ve read in recent years, and I could rarely get through more than 10 or 20 pages at a time. But it really was fantastic. She covers so many topics related to LLMs — architecture, evaluation, dataset curation, RAG, hallucinations, capturing preferences via explicit and implicit signals etc. — and goes into the perfect amount of depth. Her explanations are also crystal clear with great analogies. One fun thing I would do was ask ChatGPT or Claude about topics I wanted more detail on, which felt very meta lol.

It’s not easy to write a book about a field evolving so rapidly but Chip focuses on fundamentals more so than current news. I’m sure a new topic will come around soon and Chip will write a book on that too, and you better believe I’ll be reading it. Hopefully not too soon though because my brain is tired.

If you only read one book about how LLMs actually work, this is the one you want!

[Ayo]

AI Engineering by Chip Huyen

This was a vast, ambitious book. Some sections - especially model fine-tuning and evaluation - were deeply technical, while others were intentionally more accessible.

Chip Huyen takes care to build from first principles before diving deep. Right from the start, she clearly distinguishes AI engineering from ML engineering, which is a necessary and timely clarification amid today’s blurred terminology. AI engineering, as she defines it, focuses on building applications around foundation models - bringing with it a distinct set of challenges compared to classical ML systems. Evaluation, in particular, becomes slippery and probabilistic when outputs are generative and resist standardized assessment.

I was reminded of her earlier book, Designing Machine Learning Systems, which I read for an MLOps class in grad school. The same strengths carry over here: concepts are broken down methodically, explained simply, and layered with care. Chip is an excellent teacher.

That said, I found myself looking for a bigger reveal. While the book is thoughtful and well-structured, it didn’t uncover anything that felt fundamentally new to me. Still, it was worth the read - and I enjoyed the clarity and rigor she brings to a rapidly evolving field.

[Bugzmanov]

3.5 stars. It might be an issue with an editor, but the book is very verbose. It spends a lot of tokens on pretty basic definitions and concepts.
The first 4 chapters of the book goes through the basics: what is foundational model, what is fine tuning, how to evaluate, etc. Watch Anrej Karpathy "Deep Dive into LLMs like ChatGPT" (https://www.youtube.com/watch?v=7xTGN...). Most likely you would spent the same amount of time reading the book chapters, but mental models that Andrej provides are significantly more powerful in understanding how LLM work.
I liked the second part of the book (starting from chapter 5) significantly more. It goes into nitty-gritty of actual LLM-based AI engineering. This is unique offering of this book, that's not being covered by others.

[Scott Pearson]

It's always daunting to pick up a technical book that's over 500 pages long or 21 hours long. However, this book did not disappoint. Not every section, of course, addressed my particular needs. However, the entire treatise was clearly communicated with a broader technical audience in mind. That should be no surprise because Chip Huyen, besides being an AI expert, taught graduate school classes in AI at Stanford and writes science fiction as a side hobby. This book is simply the best technical introduction I've encountered to date.

The book starts with high-level concepts about AI, which would be accessible to all sorts of scientific folks. Then it focuses on technical topics that are of most interest to engineers. It does an excellent job of centering around concepts first and not being wedded to particular technologies which will soon change. I valued the insights so much that, after listening to the audiobook, I even bought a paper copy to have for a reference.

I plan to continue to read about AI engineering, but given that I haven't taken formal coursework in the topic, this book served as an equivalent to a graduate school class to give me confidence to dive deeper. Although some math were presented, the audiobook was incredibly accessible, unlike with some technical books. For those who spend time commuting in cars, I recommend listening to the text if you don't have time to flip through a paper book.

Overall, this book raised my game significantly about AI. Where other books obscure with technical jargon, this book enlightens with clear concepts. I still need to brush up on a few focused topics to ready myself for a project, but I'm much more fluent about the ideas than before. I highly recommend this in-depth introduction, at least for the next few years until the field outpaces our knowledge once again.

[Evan Oman]

A timely, mostly broad but sometimes deep, overview of AI engineering as of late 2024

The author mixes some of the latest ideas—many from just months before release—with timeless patterns that will stay relevant for years (like emphasizing evaluation and gathering user feedback). It highlights all the creative ways people are leveraging, evaluating, and training models—I walked away excited by the possibilities!

Some assorted takeaways:
• AI engineering is emerging as its own niche somewhere in between product, software engineering, and ML roles.
• The “R” in RAG can be any retrieval method—it’s just ranking documents. Semantic search over a vector DB is just one option; TD-IDF and BM25 work too.
• AI-as-judge performs well in many scenarios and is widely adopted.
• Use RAG to address knowledge gaps; fine-tune to fix behavioral gaps.
• Non-integer quantization rates (e.g. 1.58 bits) are just weighted average quantization rates across different parts of the model.
• Foundation-model teams use all sorts of clever tricks to boost training data:
• Perturb code samples and verify they still run.
• Generate instruction-solution pairs by generating a reasonable instruction for a known high-quality solution.
• nvidia-smi only shows that your GPU is active—it doesn’t show how hard it’s working:
• MFU (Model FLOPS Utilization): percent of peak FLOPS in use (∼50% is good for training; inference is lower).
• MBU (Model Bandwidth Utilization): percent of memory bandwidth in use.
• Even if users don't leave explicit feedback, there are lots of ways to infer implicit feedback
• e.g did they take a suggested action, did the sentiment of inputs trend up or down, did they regenerate the response, did they correct the model
• A single H100 GPU running for one year uses about 7,000 kWh—roughly 70% of a typical American household’s annual power.

[Chí]

This book serves as a handbook for those looking to build applications with available foundation models. Chip Huyen, with her extensive experience in the field, guides readers through the process of building AI systems—from model selection and evaluation to prompt engineering, as well as advanced techniques like Retrieval-Augmented Generation (RAG), Agents, and fine-tuning.

Rather than being a typical tutorial, this book is more like a collection of insights and experiences from Chip Huyen’s personal and professional journey in AI application development. It provides practical advice on handling various scenarios, focusing more on engineering rather than research. There’s no code or mathematical formulas, making it accessible even to general readers, though AI professionals will find it particularly enlightening.

Despite being in English, the book is easy to read, with no overly complex vocabulary. The writing style is clear, coherent, and easy to understand.

Highly recommended for those looking to grasp the practical aspects of building AI applications with foundation models.

[Daniel De Los Santos]

Chip Huyen’s AI Engineering is a concise, hands-on guide that bridges the gap between AI research and production systems. It emphasizes building scalable, maintainable, and continuously improving AI applications. Key strengths include its focus on real-world MLOps practices, deployment strategies, data-centric AI, and reproducibility. The book is tool-agnostic but provides practical design patterns, making it ideal for engineers moving from model development to operationalization.

[Thư]

great overview of AI engineering. will write a detailed review later but in general my favorite chapters are the ones about sampling and inference optimization.

[Avraam Mavridis]

Great intro

[Marian]

Відгуків на тех літературу не буде. Не памʼятаю коли останній раз читав профільну літературу яка була б настільки корисною або про це розповісти іншим.

[TK]

Coming from a person who built agents and shipped them to production, I can say it's a good conceptual book, meaning it is good at showing and explaining AI and agents' techniques, but it lacks how it should be implemented and more detailed examples or case studies. Example: I could understand what the evaluation process for agents is, but it was not enough to implement one from scratch and improve it.

In retrospect, I think this is the kind of book that is more valuable in two cases:
1. Review concepts
2. Go straight to the topic you need (e.g. you're implementing offline/online evals for your agent; you'll gain a lot of valuable insights if you read the "Evaluation Methodology" and "Evaluate AI Systems" chapters)

I'm not saying it's not worth reading it cover to cover, but in my opinion, it's more valuable approaching in these case scenarios. If possible, I would pair it with building simple examples (e.g. ADK, Langfuse guides) to visually understand the concepts you are learning in practice.

That said, the two most interesting chapters for me were "RAG", "Finetuning", "Evaluation Methodology", "Evaluate AI Systems". They are a great backbone for agent iteration improvement. A bit biased, because they were the exact topics I was working on at the time.

[briz]

Done! OK, that took a while. Overall, distilling it to a singular purpose - did I learn from it? - the answer is, "ya." But did I learn a sufficiently satisfying amount from it? No, not at all. This was only a starter!

Quick overview
The problem with the book - as Jake said - is that it's trying to cast a very wide net. From the intro, it seems the author, Chip Huyen, is trying to write an accessible "intro" to "AI" for software engineers, data scientists, and would-be founders. She assumes basically no special background in the technology, but - at the same time - is not aiming to write a proper undergraduate-level textbook on the subject (which is kinda what the subject requires!). As a result, it all feels very quick and surface-level.

So what's covered? Lemme jog my memory and see how much I retained (lol):
- "AI is cool and useful" (soooo many highlights and spicy marginalia here)
- AI mostly means large language models (LLMs), but it can also incorporate computer vision, speech-to-text, text-to-speech, and so on.
- Brief dive into LLMs and natural language processing: like, embeddings are cool, LLMs are big neural nets, the attention mechanism was a big step up, the transfer mechanism also. Even briefer mention of how all the cutting edge LLMs are basically closed-source, profit-driven moats that don't share the neural net architecture, the weights, the training data, or the post-training steps. But I'm not bitter...
- Long stretch about "evaluating AI models", and how difficult that is. Why is it difficult? Because human knowledge is sooooo expensive and often inconveniently locked between the ears of actual humans. As a result, Huyen advises (and maybe the industry is coagulating around?) "AI judges" - aka, use an LLM to evaluate the answers of another LLM. Also, defining "better" is hard when you're subjectively grading generated slop.
- Some cool stuff about "post-training", fine-tuning, RAG (retrieval augmented... something... generation?). Aka, building on top of the "foundational models" (aka, OpenAI, Anthropic, Gemini) by either, in order of difficulty, (a) prompt "engineering" (aka, ask it nicely, ask it a lot), (b) RAG (tell it to look things up), or (c) post-training (actually train the last few layers of the neural net again). Also some intriguing stuff about smushing models together (mixture of experts). No statistical concerns here about correlated training corpuses (corpi! yay Latin of meatspace) and orthogonality and, like, what we learned with ensemble methods in traditional, pre-LLM machine learning (e.g. a Random Forest vs. a bootstrap aggregated model with correlated trees)?
- Data engineering issues - again, an alarming section about using LLMs to generate synthetic data so that we can make more LLMs. Insufficient statistical concern here!!
- Full-stack, UX research-type discussion about how to integrate your "AI" into an app with actual, human users. Some very interesting, but very brief stuff about human-computer interaction, basically?

OK, so the good stuff: What did I learn?
This was definitely a helpful "overview" book: it gave me a lot of structure to the otherwise disparate ideas I have had about LLMs. For example, I found it very helpful to disambiguate the post-training step into specific workflows like prompt "engineering", RLHF (reinforcement learning with human feedback), RAG, teacher-student models, and so on.

I liked the very brief history of the field, how the "Attention is All You Need" paper/attention mechanism is situated within that field (I thought it was THE thing that unlocked this strange alien intelligence, but it is apparently only A thing). I was VERY tantalized by the discussion of embeddings.

I found the evaluation section super useful to, again, structure this otherwise ambiguous space.

Oh yeah - and I love that this book has a repo with tons of additional resources.

The not-good stuff
I think I would have felt very differently about this book had I read it last year, pre-AI Con, pre-AI bubble. Living in this bog of cynicism now, I couldn't help but roll my eyes at the relatively uncritical discussions around, e.g., the fact that all the cutting edge models are closed weight. That's not science!

Relatedly, the "how to evaluate your model for your needs" section was frustratingly vague and unprincipled - and never called out the elephant in the room: If I can't do any descriptive stats of the text corpuses in the training dataset, how can I, well, understand or trust anything? (I did like Huyen's table on languages which are most disproportionately underrepresented in the main training corpuses out there: apparently Punjabi is like CRAZY underrepresented!) But the evaluation section felt like it boiled down to Vicki Boykis's joke, that all AI evaluation is a "vibe check".

Similarly, the discussion of using AI judges, for example, or using synthetic training data, without a discussion of the statistical implications of that, felt really unintuitive. For example: iirc Huyen mentions how training data biases will be amplified in synthetic data creation. That's true - and it's important to acknowledge. But it's only one aspect of the wider problem: when your data is highly correlated (even duplicated), then how can you extract more information from it? For example, if you use Claude 4.5 as your LLM base model - and then use Claude 4.5 (or another Claude, for that matter) prompted to be your "AI judge" for the original model - isn't that, by definition, uninformative? Like how bootstrap aggregating (bagging, the machine learning method) can lead to correlated trees?

Basically, I would have appreciated more foundational statistical thinking throughout. (And, in Huyen's defense, this might be something to do with the field. For example: this paper, which is basically like, "Hey Anthropic/OpenAI, you should probably put error bars on your evals...": https://arxiv.org/abs/2411.00640 Basic stuff!!!)

[Jeevan]

Yet another comprehensively researched book by Chip and this time on the emerging field of AI engineering - i.e. building applications on top of foundation models. Many chapters in the book are hard to write because of the sheer amount of progress in just the last few years. Kudos to the author for organizing the content, including ton of references and explaining the origin stories of the key ideas. The references to Sherlock Holmes, Shannon make the reading more interesting. A must read (continuous read) if you are a practitioner in this field.

[Iván Peralta]

A great overview of the AI Engineering state of the art by the end of 2024, "sadly" because of the evolution speed of AI, it might get partially obsolete in a few months. But I'm confident the structure will keep relevant.

[Jack]

This book is an attempt to name and codify a discipline that emerged faster than its vocabulary. Its lens is systems engineering rather than model research: it assumes the model is a given, purchased or downloaded rather than trained, and asks what remains for the engineer to do. The central thesis is that model-as-a-service inverted the traditional machine learning workflow, so that development now begins with the product and moves backward toward data and model, and that the binding constraint on quality is not model capability but evaluation.

The framework has three moving parts worth remembering.

First, an adaptation hierarchy ordered by cost and invasiveness: prompt engineering, then retrieval augmentation, then finetuning, with the argument that teams should climb this ladder only when evidence forces them to, and that finetuning is generally the wrong first move because it shapes behavior and format more reliably than it installs new knowledge.

Second, evaluation treated as an engineering artifact rather than a reporting step. Because foundation model outputs are open ended, the book argues that conventional accuracy metrics collapse, and it spends unusual space on the alternatives: comparative and preference-based evaluation, application-specific rubrics, and the AI-as-a-judge approach, which it presents as scalable but circular and prone to characteristic biases.

Third, an inference and serving layer where cost and latency are treated as design variables rather than infrastructure trivia.

That third part is where the book distinguishes itself from most application-level writing. It insists on decomposing latency rather than quoting a single number, separating time to first token from per-token generation, and it grounds serving economics in hardware realities, notably that memory bandwidth rather than raw compute often governs throughput during decoding. Around this sit the operational concerns: caching, routing cheap models first and escalating on failure, guardrails, observability, and user feedback loops as sources of proprietary data. Dataset engineering gets similar treatment, with quality weighted above quantity and synthetic data flagged as a compounding-artifact risk rather than a free lunch.

Huyen's evidence is practitioner evidence. The book leans on distilled industry experience, published research and benchmark literature, and generalized patterns from production systems rather than on controlled experiments or a signature case study. This is worth flagging for later recall: the argument appears to rest on the credibility of accumulated practice more than on any single decisive demonstration, so a reader looking for a memorable narrative anchor will not find one.

Its strengths are taxonomic. It clarifies unusually well why teams waste money, typically by finetuning before they can measure, by treating retrieval as a model problem, or by optimizing a system they never instrumented. It also refuses tooling tutorials in favor of mechanisms, which is why it has aged better than most 2024 vintage writing on this subject.

The main vulnerability is breadth. Each chapter surveys where a specialist would argue, and the sections closest to genuine expertise, particularly inference optimization and finetuning, are introductions rather than working references. The strongest opposing reading is that "AI engineering" is not a discipline but a temporary artifact of the API era, and that as agent frameworks, longer contexts, and cheaper training push capability around, today's adaptation ladder becomes historically contingent advice dressed as fundamentals. That critique has force. The fair rebuttal is that evaluation discipline and cost decomposition survive whichever layer moves, but the book asserts this durability more than it demonstrates it. A secondary weakness is a quiet infrastructure and scale bias, plausibly traceable to the author's background, which underweights small-team constraints and non-LLM baselines.

Practically, the book functions as a map and a filter rather than a manual. Its real-world implication is that measurement capability, not model access, is the competitive asset, and that whoever owns the eval pipeline and the feedback loop owns the product. Read it if you are building on foundation models, orienting yourself in the field, or needing shared vocabulary across engineering and product. Skip it, or read selectively, if you already ship these systems and want depth in one area, or if you want code you can run. For anyone using it as a launchpad toward inference or finetuning specialization, treat chapters seven and nine as an index of what to study elsewhere, not as the study itself.

QUICK RECALL
* Thesis: models are given; evaluation is the real bottleneck.
* Adaptation ladder: prompt, then retrieve, then finetune.
* AI-as-a-judge: model grades output; scalable, circular, biased.
* Latency decomposition: first-token time versus per-token generation time.
* Finetuning shapes behavior; retrieval supplies facts.
* Best use: deciding what not to build, and when.
* Weakness: broad survey; does durability outlast the API era?
* Memory anchor: the measurement moat.

-LLM

[Thomas Falezan]

A must-read for any software engineer. Foundation models are transforming not only how we build software, but also what we put in front of users. Beyond conversational chatbots, every traditional software product is becoming AI-centric with features such as AI assistants in email apps to AI-powered editing tools in video platforms like YouTube. Understanding how to build AI-first applications is essential to thrive under this new paradigm, and AI Engineering by Chip Huyen is the perfect guide.

The book takes a holistic view of the AI stack, covering a wide range of subjects from model training, serving, and evaluation to prompt engineering and fine-tuning. It also proposes conceptual frameworks for navigating architectural trade-offs, helping you answer questions like “should I use a model API or serve in-house?” or “should I invest in RAG or fine-tuning?”.

Rather than focusing on specific tools that quickly become outdated, Huyen focuses on the enduring methods used to build and scale systems. Despite the speed at which the field is moving, I believe this book will be a reference for years to come.

[eri b.❀]

Really liked Huyen's well-researched, concise and clear explanation of AI topics, clearly applied to a production setting. I'd have loved a little more deep on the caveats of AI, especially generative AI, but overall I couldn't have asked for a better introduction to AI Engineering.

[Regis Hattori]

The book serves as an excellent starting point for anyone looking to build real-world applications powered by generative AI.

Instead of getting bogged down in implementation details that quickly become obsolete, the author provides a comprehensive overview that goes deep enough to map out the domain's "unknown unknowns"—giving you the foundational knowledge needed to explore specific topics further on your own.

The book's greatest highlight is how it moves beyond pure technology:

Behavioral Sciences: In the chapters covering user evaluation and feedback, Chip Huyen reminds us that we are dealing with subjectivity. To truly understand the behavioral biases affecting the product, books like Thinking, Fast and Slow and Nudge become indispensable complements.

Systems Thinking: Subtle biases in a prompt or UI design can be dramatically amplified by feedback loops. Approaching AI as part of a complex system is what separates a quick prototype from a production-ready application.

An essential read for engineers and product leaders looking to go beyond the basics.

[Joao Fernandes]

Coming from an ML background I picked up this book thinking I would skim it quickly as I was only interested in learning more about fine-tuning, evaluation and inference optimization. I thought the book was mainly about calling inference APIs and building apps. Boy was I wrong! The book is wonderfully written by a seasoned professional in the ML world, and is full of substance! More than people that are only now touching the world of AI, I reccommend it to any ML practicioner.

[Patrick (Kunle)]

A tight (just ~500 pages) yet comprehensive dive into developing practical applications by adapting foundation models.

The book covers pretty much every major topic to a solid degree: how LLMs are pre-trained (transformer architecture and the attention mechanism), evaluating models and AI systems, prompt engineering, RAG, finetuning techniques, dataset engineering, and inference optimization. The final chapter was a real treat, sketching the architecture of an application that brings together all the concepts from the earlier sections.

I was looking for both a strong foundation and a reliable reference on AI engineering, and this book delivers on both counts. Highly recommended!

[Julien Delange]

This book is made for engineers who know how to code, build frontend or backend applications but are still figuring out how to build AI application or rather, applications that integrate AI. If you have 10+ years of experience and are starting to build AI applications: this is the perfect book to read.

The author does not try to be too general through the text, it's clear they have a strong experience in designing and building AI systems. From recommendations about how to approach building AI application to prompt engineering or overall system architecture, this book is an excellent start that should be enough for most application builders.

[Lensvol]

I really liked this book! It systematically gives you information about this hot new topic in a measured way at just the right level of abstraction.

And it is nice to read a book about _engineering_ side instead of yet another "How to change your life with ChatGPT" or "Prompts for Dummies"!

I would also recommend this book for those who oppose AI and want to fight it, as it outlines all the juicy parts and vectors for attack.

[Baran Cezayirli]

This is one of the best books you can read to make sense of AI engineering without the hype. Each chapter is written with great care and excellent flow; all chapters are referenced with papers to back up.

[Thang]

Good book and informative if you want to understand the current state of LLM development process. The book provides a broad view, but I feel a lack of depth and practical examples. Also, it focuses on trending techniques, so I wonder if it would become obsolete after short time.

[Msalem]

Excellent book. Highly recommend for anyone interested in understanding what current day AI is all about.

[Yoel Monzón]

This was one of the hardest books I’ve read, but also one of the most valuable.

The book covers a lot of topics around modern AI systems like foundation models, prompting, RAG, agents, and fine-tuning, giving a clear picture of what AI engineering actually looks like today. Some parts, especially fine-tuning, were tough to fully understand, and there were many new terms for me. Still, I really liked how the author explains complex ideas in a smooth and approachable way.

It took me longer than expected to finish, and honestly I wish I had gone through it faster. But it was worth it. This book feels like a guideline for where software engineering is heading. The shift toward AI engineering is very real, and this book helps you understand what you need to learn to stay relevant.

Overall, a challenging read, but definitely a must if you want to keep up with the future of software engineering.

[bimri]

Chip must have gone through tremendous effort to compile this tome. (For that, this book deserves full merit on the rating score.) It had its lingering difficulties in explanations of research concepts underpinning current AI breakthroughs; but as the disclaimer to this book went, it was an expectation at the end of the day.

What this book is great at is the ultimate compression of so many moving parts in AI sea of content. My favorite bits is when Chip fervently talked about AI accelerators & especially on the hardware side of things, I bet Chip owns NVIDIA stocks & wrote this section as though Jensen himself would read it!!!

Kudos to the author for this aggregated knowledge and structure instilled in defining this AIE discipline. For those who are wondering, bruh - be ready for so much evaluations, monitoring & feedback of AI systems! Amor Fati!