Titus Winters, Tom Manshreck, and Hyrum Wright's practical lessons in scale, culture, testing, and long-term maintainability. Learn how Google builds software that lasts decades.

Software Engineering at Google is the book I reference when someone asks how to build software that lasts. Winters, Manshreck, and Wright share lessons from maintaining codebases that have been around for decades, and the insights are gold. The chapter on testing—why Google writes so many tests, how they structure them, what they test—helped me understand why our test suite was failing us. The section on code review culture showed me why some teams have better code quality than others, and the chapter on documentation gave me a framework for writing docs that actually get read. The book is practical: it's not about Google's specific tools, it's about the principles and practices that work at scale. My only critique is that some practices assume Google-scale resources, but the principles apply anywhere. I've recommended it to teams trying to improve their engineering culture, and it's helped them see that small changes—better testing, code review standards, documentation—compound into better software. Essential reading for anyone building software that needs to last.

Titus Winters and team share lessons from maintaining codebases for decades. Learn Google's approach to testing, code review, and building software that lasts.

Software Engineering at Google: Lessons Learned from Scale

Software Engineering at Google: Lessons Learned from Programming Over Time

Michael Feathers' must-read for anyone inheriting messy systems, refactoring safely, or adding tests. Learn how to work with code you didn't write and make it better without breaking it.

Working Effectively with Legacy Code is the book I read when I inherited a codebase that had no tests and couldn't be changed safely. Feathers' techniques—sprouting methods, characterization tests, dependency breaking—gave me a systematic approach to adding tests to untested code. The chapter on dependency breaking showed me how to extract dependencies so I could test code in isolation, and the section on characterization tests helped me understand what legacy code actually does before I tried to change it. The book is practical: every technique includes code examples showing the before and after, and Feathers explains when each technique works and when it doesn't. My only critique is that some examples are Java-focused, but the principles apply to any language. I've used this book to add tests to three different legacy systems, and each time it gave me the confidence to make changes without breaking things. Essential reading for anyone working with code they didn't write.

Michael Feathers' guide for inheriting messy systems, refactoring safely, or adding tests. Sprouting methods, characterization tests, and dependency breaking.

Working Effectively with Legacy Code: Refactoring Guide

Working Effectively with Legacy Code

Curated maintainability products we use and recommend. Each item tested in real-world scenarios. Find 2 products with detailed reviews, pros, and cons.

Maintainability Products

Software Engineering at Google: Lessons Learned from Programming Over Time

Working Effectively with Legacy Code