diff --git a/second-edition/src/ch00-00-introduction.md b/second-edition/src/ch00-00-introduction.md
index 0008f023e..bc8b459cb 100644
--- a/second-edition/src/ch00-00-introduction.md
+++ b/second-edition/src/ch00-00-introduction.md
@@ -108,6 +108,44 @@ Rust’s ownership system. By contrast, if you’re a particularly meticulous
 learner who prefers to learn every detail before moving onto the next, you may
 want to skip Chapter 2 and go straight to Chapter 3.
 
+Chapter 5 discusses structs and methods, and Chapter 6 covers enums, `match`
+expressions, and the `if let` control flow construct. Structs and enums are the
+ways to make custom types in Rust.
+
+In Chapter 7, you'll learn about Rust's module system and privacy for
+organizing your code and its public API. Chapter 8 discusses some common
+collection data structures provided by the standard library: vectors, strings,
+and hash maps.
+
+Chapter 10 digs into generics, traits, and lifetimes, which give you the power
+to define code that applies to multiple types. Chapter 11 is all about testing,
+which is still necessary even with Rust's safety guarantees to ensure your
+program's logic is correct. In Chapter 12, we'll build a subset of the
+functionality of the `grep` command line tool that searches for text within
+files and we'll use many of the concepts we discussed in the previous chapters.
+
+Chapter 13 explores closures and iterators: features of Rust that come from
+functional programming languages. In Chapter 14, we'll explore more about Cargo
+and talk about best practices for sharing your libraries with others. Chapter
+15 discusses smart pointers provided by the standard library and the traits
+that enable their functionality.
+
+In Chapter 16, we'll go through different models of concurrent programming and
+how Rust helps you to program using multiple threads fearlessly. Chapter 17
+looks at how Rust idioms compare to Object Oriented Programming principles you
+may be familiar with.
+
+Chapter 18 is a reference on patterns and pattern matching, which are powerful
+ways of expressing ideas throughout Rust programs. Chapter 19 is a smorgasbord
+of advanced topics that you might be interested in, including unsafe Rust and
+more about lifetimes, traits, types, functions, and closures.
+
+In Chapter 20, we'll finish up with a project where we'll implement a low-level
+multithreaded web server!
+
+Finally, there are some appendices. These contain useful information about the
+language in a more reference-like format.
+
 In the end, there’s no wrong way to read a book: if you want to skip ahead, go
 for it! You may have to jump back if you find things confusing. Do whatever
 works for you.
@@ -119,9 +157,6 @@ that situation. As such, if you pick a random example, it may not compile!
 Please read the surrounding text to make sure that you didn’t happen to pick
 one of the in-progress examples.
 
-Finally, there are some appendices. These contain useful information about the
-language in a more reference-like format.
-
 ## Contributing to the Book
 
 This book is open source. If you find an error, please don’t hesitate to file