"Looks Good To Me": Constructive code reviews

by Adrienne Braganza

Deliver code reviews that consistently build up your team and improve your applications.

“Looks Good to Me” offers a unique approach to delivering meaningful code reviews that goes beyond superficial checklists and tense critical conversations. Instead, you’ll learn how to improve both your applications and your team dynamics.

“Looks Good to Me” teaches you how

• Understand a code review's benefits proactively prevent loopholes and bottlenecks
• Co-create an objective code review system
• Clarify author, reviewer, team lead/manager, and the team itself
• Establish manageable guidelines and protocols
• Align with your team and explicitly document the policies they will follow
• Automate code quality with linting, formatting, static analysis, and automated testing
• Compose effective comments for any situation
• Consider combining code reviews with pair programming or mob programming
• AI for code reviews

Inside “Looks Good to Me” you’ll find comprehensive coverage of every part of the code review process, from choosing a system to keeping reviews manageable for everyone involved. With this mix of tools, processes, common sense, and compassion, you’ll run a highly effective review process from first commit to final deployment.

Foreword by Scott Hanselman.

About the technology

Transform code reviews into the positive, productive experiences they’re meant to be! Whether it’s your code under the microscope or you’re the one giving the feedback, this sensible guide will help you avoid the tense debates, fruitless nitpicking, and unnecessary bottlenecks you’ve come to expect from code reviews.

About the book

“Looks Good to Me” teaches the considerate, common sense approach to code reviews pioneered by author Adrienne Braganza. You’ll learn how to create a cohesive team environment, align review goals and expectations clearly, and be prepared for any changes or obstacles you may face. Along the way, you’ll master practices that adapt to how your team does things, with multiple options and solutions, relatable scenarios, and personal tidbits. You’ll soon be running highly effective reviews that make your code—and your team—stronger.

What's inside

• Why we do code reviews
• Automate processes for code quality
• Write effective comments

About the reader

For any team member, from developer to lead.

About the author

Adrienne Braganza is an engineer, speaker, instructor, and author of the bestselling book Coding for Python.

Table of Contents

Part 1
1 The significance of code reviews
2 Dissecting the code review
3 Building your team’s first code review process
Part 2
4 The Team Working Agreement
5 The advantages of automation
6 Composing effective code review comments
Part 3
7 How code reviews can suck
8 Decreasing code review delays
9 Eliminating process loopholes
10 The Emergency Playbook
Part 4
11 Code reviews and pair programming
12 Code reviews and mob p

Genres: Software, Technology, Programming, Computer Science

352 pages, Paperback

Published January 7, 2025

About the author

Adrienne Braganza Tacke, AKA Adrienne B. Tacke

Reviews

[Sebastian Gebski · Rating 3 out of 5]

I reached out for LGTM as a test of OReilly's audiobook offering - to double-check if it's a viable option for a tech book that is not fully packed with code samples and arch diagrams.

Here's what I learned:
1. The audiobook form worked nicely here; I had no issue with following the content and the presented chain of thought.
2. The book is an entry-level, smooth intro to the concept of code reviews - it covers all the typical pieces of information one does expect in that context: the rationale behind code reviews, bootstrapping code reviews, tooling support for code reviews, mixing code reviews with other practices, optimizing the code reviews in your org (within some strict limits). There are even chapters on CRs in mob programming and applying Gen AI in code reviewing - nice additions, IMHO.
3. Unfortunately, I missed some non-trivial topics that go beyond what's considered "a good practice":
- code reviews and the law of diminishing returns - when are there too many eyeballs?
- CRs for trivial cases -> automating what can be automated
- pro-active vs re-active code review patterns
- layered code reviews (incl. bar raising)
- code reviews on a higher abstraction level
etc.

That all makes it a good book for people who are either starting their career in tech OR have never had the luck of working for an org with mature, effective code review patterns & practices implemented.

[Peter Aronson · Rating 4 out of 5]

This is a fairly opinionated book, but I believe it has to be -- if it tried to take a neutral tone for everything it wouldn't really recommend anything. I don't agree with everything, but I don't mind that. It is also polite (if at times firm) about its opinions, which is a nice change from some other authors in the technology space. It is also a surprisingly dense book, with a lot of details and a lot of suggestions.

Some other reviewers complained that it is too basic. I can see where they are coming from, although I am not sure how you could discuss a lot of these topics without going over the basics first. I will say that while it discusses both how to set up a code review process where there isn't one, and how to improve an existing code review process, it seems to me to focus much more heavily on the former than then latter. And it does at times seem to skim over hard problems like breaking up large chunks of functionality so they can be reviewed in pieces. Admittedly, this is the sort of problem everyone who does code reviews is likely to encounter and struggle with.

The book does seem to assume a particular development process where software is being developed for in-house use, and issues are very separate from pull requests. I happen to work on Commercial Off-The-Shelf (COTS) software, with occasional forays into Software-as-a-Service (SaaS), and the working environment is rather different. We don't want a mechanism for emergency installs without normal approval because that's not how we work. Software is exposed to users at set intervals, not daily! (Our users sometimes ask for it to change less frequently, actually.) But, like the opinion part, you can just take what you want from this book and ignore the rest.

The last three chapters -- Code Reviews and Pair Programming, Code Reviews and Mob Programming, and Code Reviews and AI -- are interesting windows into a different world.

Overall, I would say it was definitely worth reading. If nothing else, it makes me more mindful of what I put in my own pull requests and how I address other people's.

[Flayol Frederic · Rating 5 out of 5]

Looks Good to Me is a must-read for anyone working in software development or anyone who's ever dealt with the intricate and sometimes intimidating process of reviewing code. The book approaches the technical aspects of code reviews with clarity and practical insight, offering advice for both beginners and seasoned developers alike.
The writing is accessible yet detailed, covering various aspects of code reviews, from spotting bugs and inefficiencies to ensuring that code is maintainable and scalable. The author brings in real-world examples and scenarios, offering tips on how to approach tricky situations, handle difficult feedback, and foster a positive and collaborative code review culture.

What’s particularly refreshing is the book’s focus not only on the technical side of things but also on the human aspect of code reviews.

n conclusion, Looks Good to Me is an essential guide for anyone involved in code review processes. With a perfect balance of technical detail and interpersonal insights, it’s both practical and thought-provoking. Developers looking to improve their skills in reviewing code or aiming to create a more collaborative and supportive team environment will find this book invaluable.

[Nick · Rating 4 out of 5]

I picked up this book after hearing the author's interview on a podcast. I think for me personally, the book wasn't that useful. It spends a lot of its time on technical people and technical teams that don't have any code review infrastructure set up. One part is just trying to convince your team that code reviews matter.

The book refers to the company I work for a few times, as a positive case. I'm glad for that, but it also signals that there really isn't much that I could've gleamed

[Stijn · Rating 5 out of 5]

I usually don't review many technical books here, but I gladly make an exception for this one. Very well written; human, yet technical; humourous at times, yet important. I'm going to make a bold statement here: I feel that every time that I have a positive, useful vibe from technical books, it is written by women. Men often tend to drown themselves in technical details, instead of focusing on the human aspect.
Super great read.
More of this please!

[Edin Kapić · Rating 5 out of 5]

A clear, no-nonsense, practical guide to create and maintain a team code review practice. It begins with the bare essentials of why code reviews are necessary, it guides you to pick and customise the process to suit your team, and it ends in a exploration of what further steps you can take for your team.

I learned a lot, even as an experience code practitioner.

[Emmanouil Chardalas · Rating 5 out of 5]

During code reviews, providing and receiving feedback is not always as simple as it may seem. This book offers a plethora of guidance on how to write, evaluate, and improve code reviews on a team level and from both perspectives, strong and soft skills.

[Matt Eland · Rating 5 out of 5]

A comprehensive exploration of code reviews in modern software engineering with many insights into writing, reviewing, and refining code reviews for various types of teams and organizations.

[Rasmus · Rating 2 out of 5]

Good core content but for my taste it would require a more formal tone from the author and could be a lot shorter with a stricter editing.

[José Córdova · Rating 3 out of 5]

Nice book. I wanted to read something out of the book. there are a lot of information about how to create a good PR, that kind of information can be found even in the provider you want to use, like Github, Gitlab, and so on.

It's nice to keep in mind the intention of a good pull request, know how to be specific and having empathy.

[Jasminex · Rating 4 out of 5]

The biggest thing this book teaches me is in a review process the owner and the reviewer have different responsibilities, and both of them should respect each other.

[Camal · Rating 2 out of 5]

I was excited about this book because my work experience has made it clear that communication is one of the most important skills for achieving great things.

I was curious about what a whole book would cover on code reviews; Spoiler: It contains a lot of repeated sentences and not many insights.

50% of the book explains basic concepts in great detail.

There are some gimmicks and ideas in the book I will experiment with, but I would not suggest reading it.

The topic is too practical for me, and the book missed the opportunity to make it more accessible.