Code review
Code review is the systematic examination of source code or proposed changes to assess correctness, quality, risks, or conformance to requirements or standards.
"Looks Good to Me"
The code review process is the organized set of rules, roles, workflows, and practices governing how code reviews are performed.
- How it is used
- Organizes collaborative inspection of code against team standards before integration, using workflows, roles, feedback, and signoff.
- How deep it goes
- Descends from definition and benefits to workflow components, team choices, review criteria, and process-building decisions.
- Examples
- Uses an invoice parser failure, a wrong-cache pull request, and pull request workflow diagrams to make review risks and mechanics concrete.
- What you can do after
- Build it from scratch or improve it collaboratively by selecting goals, tools, workflow, reviewers, approval rules, and team guidelines.
Lead Developer Career Guide
A systematic examination of source-code changes by one or more developers to identify defects and assess adherence to standards.
- How it is used
- Positions code review as a lead developer’s quality safeguard during project delivery.
- How deep it goes
- Gives practical review priorities and mentoring examples, but stops short of a line-by-line review workflow.
- Examples
- Uses a mentor’s approval followed by quiet edits to show why constructive pull-request comments matter.
- What you can do after
- Practice/perform reviews to catch problems early and give developers constructive feedback in pull or merge requests.
Vibe Engineering
The manual examination of proposed source-code changes to identify defects, risks, and conformance or maintainability problems before integration.
- How it is used
- Uses human review as a pre-merge judgment gate for AI-assisted changes and as part of agent governance.
- How deep it goes
- Explains review criteria, verification gates, queue capacity, and conservative auto-merge calibration, without a detailed line-by-line review procedure.
- Examples
- Uses a legacy application migration and a 48-pull-request daily queue to illustrate change-size and reviewer-capacity tradeoffs.
- What you can do after
- Practice sizing changes for review, checking intent and architecture, and measuring the proportion of merged pull requests read by humans.
Build High Value Software Systems
The practice of examining proposed source-code changes for correctness, design, and maintainability.
- How it is used
- Uses pull-request review to catch merge-blocking problems and observe where team standards fit or fail.
- How deep it goes
- Provides merge criteria, a reviewer checklist, and a feedback loop for revising standards.
- Examples
- Uses a cache-refactoring pull request, recurring standards deviations, and AI-generated code that passes tests but obscures intent.
- What you can do after
- Practice/perform code review with explicit merge blockers, constructive comments, and ownership of AI-generated changes.
Read how Build High Value Software Systems explains code review →
A Pythonic Adventure: From Python basics to a working web app
Code review is the systematic examination of source code to identify defects, risks, and opportunities for improvement.
- How it is used
- Uses an AI assistant to inspect functions and suggest clearer, safer code.
- How deep it goes
- Explains review categories and applies them to one function, while deferring broader review methodology.
- Examples
- Uses a read_menu function, file exceptions, a list-comprehension rewrite, comments, and a list-indexing error.
- What you can do after
- Apply it via ChatGPT to request structured feedback, improve a function, add comments, and explain errors.
Read how A Pythonic Adventure: From Python basics to a working web app explains code review →
Shipping Go: Develop, deliver, discuss, design, and go again
A code review process is a defined process for examining source code to assess its quality and provide feedback.
- How it is used
- Uses pull requests to examine changes before they enter a protected repository branch.
- How deep it goes
- Gives configuration steps and practical rules for review size, conduct, and timing rather than a line-by-line inspection checklist.
- Examples
- Illustrates review size by splitting a 2,000-line change into about ten 200-line reviews.
- What you can do after
- Operate/configure GitHub branch protection to require another person’s approval and passing checks before merging.
Read how Shipping Go: Develop, deliver, discuss, design, and go again explains code review →
Think Like a CTO
Code review is the systematic examination of source code by developers to identify problems and improve quality before or during integration.
- How it is used
- Uses regular review alongside coding standards to improve code quality before deployment.
- How deep it goes
- Gives review cadence and checks for debt, documentation, and security, but no line-by-line review protocol.
- Examples
- Uses a temporary fix missed by analysis tools and a SQL-injection scenario to illustrate review concerns.
- What you can do after
- Practice/perform it regularly to flag technical debt, check documentation, and assess risks that tools may miss.
C++ Concurrency in Action, Second Edition
Code review is the systematic examination of source code to identify defects, improve quality, and check conformance to standards.
- How it is used
- Use deliberate source-code inspection to locate potential concurrency and ordinary bugs before testing.
- How deep it goes
- Develops line-by-line questions about data, thread positions, mutexes, and operation ordering, while noting that review can miss bugs.
- Examples
- Use self-explanation, written notes, or a rubber chicken, then consider whether another thread could modify the data.
- What you can do after
- Diagnose potential defects by tracing data access, mutex ownership, thread interactions, and ordering requirements.
Read how C++ Concurrency in Action, Second Edition explains code review →
Think Like a Software Engineering Manager
A code-review round is a job-interview assessment in which a candidate examines source code to identify issues and explain improvements.
- How it is used
- Uses code review to assess engineering-manager judgment in interviews and improve team code quality, collaboration, and maintainability.
- How deep it goes
- Explains review goals and practical focus areas, but stops short of detailed implementation guidance or a formal review checklist.
- Examples
- Uses interview code-review rounds, peer reviews before merging, asynchronous review tools, coding standards, and review-completion time.
- What you can do after
- Evaluate code and explain improvements in plain English, or operate a peer-review process that strengthens quality and shared understanding.
Read how Think Like a Software Engineering Manager explains code review →
100 Java Mistakes and How to Avoid Them
Code review is the systematic examination of source code by one or more developers to identify defects and improve quality.
- How it is used
- Organizes peer examination of committed changes to catch defects before release and improve broader code quality.
- How deep it goes
- Defines the review process and its benefits, but defers detailed guidance on making reviews efficient.
- Examples
- Uses committed changes, differing reviewer perspectives, and collaborative editing while code is written as contrasting examples.
- What you can do after
- Evaluate committed changes for defects, design, readability, and performance while combining review with other quality techniques.
Read how 100 Java Mistakes and How to Avoid Them explains code review →
The Art of Code
Code review is the practice of examining proposed source-code changes to identify defects, design problems, convention violations, and readability issues before integration.
- How it is used
- Prevents complexity before integration by making peer review part of a pull or merge request workflow.
- How deep it goes
- Explains review targets, revision flow, and team ground rules, but does not prescribe specific review criteria.
- Examples
- Uses pull or merge requests, peer feedback, revision, questions, suggested fixes, and approval as concrete workflow elements.
- What you can do after
- Apply via pull or merge requests to detect defects, challenge design problems, improve readability, and prevent unnecessary complexity.
Grokking Web Application Security
A code review is a systematic examination of source code by one or more developers to identify defects, security issues, and other problems.
- How it is used
- Uses peer examination as a pre-release security control and a team practice for finding vulnerabilities early.
- How deep it goes
- Explains review gates, timing, scanning, and authorization checks, but does not prescribe a detailed reviewer checklist.
- Examples
- Uses GitHub approvals, legacy code, template secrets, TruffleHog, and authorization tests against design documents.
- What you can do after
- Apply it via peer approval, passing unit tests, static scanning, and critical authorization checks before release.
Read how Grokking Web Application Security explains code review →
Also covered in
- Spec-Driven DevelopmentIn early access (MEAP)
- Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
- Generative AI in Action
- Memory Safe C++In early access (MEAP)
- The Art of Unit Testing 3e
- Coding with AI
- Software Testing with Generative AI
- Authorization in Action
- Writing for Developers: Blogs that get read
- The Quick Python Book, Fourth Edition
- GitHub Actions in Action: Continuous integration and delivery for DevOps
What to know first
- software testingSoftware testing is the systematic evaluation of software under specified inputs or conditions to assess its behavior against expected results or requirements and identify defects.
- vulnerabilityA vulnerability is a weakness or condition that makes a system, person, or group susceptible to exploitation, compromise, or other harm.
- bugA software bug is a defect that can cause software to behave incorrectly or differently from its intended or specified behavior.
- deployment pipelineA deployment pipeline is a repeatable sequence of stages that builds, tests or validates, packages, and delivers software changes toward release or deployment.
Related concepts
- artificial intelligenceused by · Artificial intelligence is the field of computing concerned with creating systems that perform tasks associated with intelligence, such as learning, reasoning, perception, and decision-making.
- LLM-powered agentuses · An LLM-powered agent is a software agent that uses a large language model to interpret inputs and generate responses or actions toward a goal.
- pull requestuses · A pull request is a version-control proposal to integrate changes from one branch or repository into another, typically supporting review and discussion before merging.
- bugaddresses · A software bug is a defect that can cause software to behave incorrectly or differently from its intended or specified behavior.
- software development life cyclepart of · The software development life cycle is the organized sequence of activities for planning, creating, testing, delivering, operating, and maintaining software.
- static analysiscontrasts with · Static analysis is the examination of source code or other software artifacts without executing the program to infer properties or identify potential issues.
Questions about code review
What is code review?
Code review is the systematic examination of source code or proposed changes to assess correctness, quality, risks, or conformance to requirements or standards.
Which Manning books explain code review?
"Looks Good to Me", Lead Developer Career Guide, Vibe Engineering, Build High Value Software Systems, A Pythonic Adventure: From Python basics to a working web app, Shipping Go: Develop, deliver, discuss, design, and go again, Think Like a CTO, C++ Concurrency in Action, Second Edition and 4 more.
What should I know before learning code review?
Manning books that teach code review usually introduce software testing, vulnerability, bug and deployment pipeline first.
What is the difference between code review and static analysis?
Code review is the systematic examination of source code or proposed changes to assess correctness, quality, risks, or conformance to requirements or standards. Static analysis is the examination of source code or other software artifacts without executing the program to infer properties or identify potential issues.
What is code review part of?
Code review is part of software development life cycle. The software development life cycle is the organized sequence of activities for planning, creating, testing, delivering, operating, and maintaining software.
What is code review also called?
Code review is also called Reviewing code.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.











