Table of contents
Title
Table of contents
Title

Manual code review

Updated

Manual code review is the line-by-line inspection of source code by a person, carried out to find security flaws that depend on context: who can call a function, what the business rules allow, and whether a control that looks present actually holds. Automated analysis runs on patterns. A manual code review runs on reasoning about intent.

The gap between the two is measurable. In Fluid Attacks’ benchmark of 36 third-party AppSec tools against a web application with 1,201 vulnerabilities across 105 CWE categories, a pentester found 743 flaws that no tool reported — 61.9% of the total, carrying 86.8% of the application’s risk exposure. The benchmark measures a pentester’s manual testing, not secure code review alone, and this page uses it for what manual analysis adds to automated tools.

This page covers what a manual code review is, how to choose what gets reviewed first, what a reviewer checks, how review of AI-generated code differs, and how to tell whether the review actually reduced risk. For the full four-stage service methodology, see Secure Code Review.

What is manual code review?

A manual code review is the systematic inspection of source code by human reviewers to find security flaws and confirm that the code follows security standards. Fluid Attacks’ documentation defines it in those terms, and adds that this expert analysis “frequently finds severe and complex vulnerabilities that automated tools alone cannot find.”

Two distinctions matter before going further. A manual code review is not the same as a standard peer review: a peer review asks whether the code works and reads well, while a manual code review asks whether an attacker can abuse it. The two use different checklists and usually different people. It is also not the opposite of automated analysis. In Fluid Attacks’ process, SAST and SCA run first, and the automated findings are used to filter false positives and guide the deeper manual investigation.

Why manual code review still matters

Scanners match known patterns; manual code review resolves meaning. The OWASP DevSecOps Guideline, in its October 2026 update, states the division plainly: “Automated scanners find known patterns; human review finds the flaws that need context,” and notes that “Scanners rarely detect broken access control or business-logic flaws.”

Two standards put code review inside the formal development process. Neither requires manual code review as such: NIST leaves the choice between human review and tool analysis to the organization, and PCI DSS accepts manual, automated or combined review.

  • NIST SP 800-218 (SSDF 1.1, February 2022) dedicates practice PW.7 to reviewing human-readable code. Task PW.7.1 requires an organization to decide “whether code review (a person looks directly at the code to find issues) and/or code analysis” applies; PW.7.2 requires the review to run against secure coding standards and the findings to be recorded and triaged in the development team’s workflow.

  • PCI DSS v4.0.1 requirement 6.2.3 states that “Bespoke and custom software is reviewed prior to being released into production,” and allows the review to be “performed using either manual or automated processes, or a combination of both.” Requirement 6.2.3.1 governs the manual case specifically: the reviewer must be someone other than the code’s author, must be competent in review techniques and secure coding, and management must approve the result before release.

NIST SSDF practice PW.5.1 mapped to Fluid Attacks security requirements

Fluid Attacks maps NIST SSDF practice PW.5.1, secure coding practices, to seven security requirements a reviewer can check against.

Neither standard treats code review as paperwork. NIST asks for issues and recommended remediations to be recorded and triaged in the development team’s workflow, and PCI DSS asks for corrections before release.

Manual code review at Fluid Attacks

Fluid Attacks runs manual code review as Secure Code Review, a service in the Advanced plan where analysts inspect source code alongside the automated testing that runs on the same repository.

What we review, and in what order

Nobody reads a million lines by hand, so the order is the method. Fluid Attacks uses AI to predict high-risk files and review them first, and statistical models “identify the systems and components that require the most attention.” Testing effort follows risk rather than uniform file coverage.

What a finding looks like

A manual code review finding is only useful if a developer can act on it. Each one arrives on the platform with the affected file and line, a CVSS v4.0 severity score, its remediation status, and the weakness it maps to in the public Fluid Attacks Database. That link makes a manual code review finding checkable: anyone can open the entry and read the impact, the recommendation and the linked security requirement.

Fluid Attacks Database entry for insecure object reference

What a reviewer checks against: weakness 013 and the security requirement it is linked to.

Manual code review versus automated analysis, with our own numbers

Evaluator

Precision

Recall (vulnerabilities)

Recall (risk exposure)

Fluid Attacks’ pentester

100%

89.6%

98.9%

Fluid Attacks’ scanner

99%

22.7%

8.8%

Third-party tool with the most true positives

72%

21.6%

4.0%

Average of the other third-party tools

—

1.7%

—

Results from Fluid Attacks’ benchmark against a web application with 1,201 vulnerabilities; the pentester row is manual testing. Seventeen of the tools failed to identify even ten.

The limit of our own numbers: more findings is not more risk covered

Read the table by column and it says something the headline numbers hide. Fluid Attacks’ own scanner reaches 22.7% recall on vulnerability count but only 8.8% of risk exposure — it finds a respectable share of the flaws and a small share of the danger. The vulnerabilities that carry weight are the ones that need context, which is the whole case for manual code review stated as a ratio.

One more caveat on scope. Fluid Attacks’ analysis of 2023 security tests on client systems found that 71.4% of risk exposure was reported by manual methods only. That figure describes manual methods as a group, not manual code review on its own.

Where the review ends: the reattack

A manual code review that stops at the report leaves the most important question open. When a developer fixes a finding, the client requests a reattack on the platform and, for manual findings, a pentester performs the verification (Platform FAQ). On privileged functions, Juan Restrepo, Certified DevSecOps Professional, writes in Fluid Attacks’ analysis of the Binance hack:

“In our Secure Code Review, analysts trace who can call each of these functions and with which identity.”

How to decide what to review first

A risk-based code review is what makes manual code review affordable at scale. Instead of spreading attention evenly, it concentrates reviewer hours where a mistake changes who is trusted. The OWASP DevSecOps Guideline lists the change types that justify a deeper look:

  • Security-sensitive code: authentication, session handling, authorization, cryptography, input parsing, deserialization and file upload.

  • Trust-boundary changes: new public endpoints, third-party integrations, new data stores, and changes to CORS or network exposure.

  • Build and delivery changes: CI workflows, Dockerfiles, infrastructure manifests and release scripts, reviewed as production code.

  • Dependency changes: new or upgraded packages and lockfile diffs, checked for provenance, maintainers and install scripts.

  • Large or unusual changes: very large diffs, generated code, and changes from first-time contributors, which should be split or given a second reviewer.

Everything on that list shares one property: the damage is not local to the line. A new public endpoint or integration redraws the system’s trust boundaries, and OWASP asks for such changes to be checked against the threat model, which takes context a scanner rarely has. A risk-based manual code review earns its cost there, not on changes that alter what a screen displays.

A manual code review checklist keeps that focus repeatable. Input validation, authentication and password management, access control and session management, cryptography and data protection, error handling and logging, and system configuration are the recurring headings, each tied to a security requirement the reviewer can check against rather than a judgment call.

Baseline review versus diff-based review

A manual code review comes in two shapes. OWASP’s Secure Code Review Cheat Sheet separates them: baseline reviews “examine the entire codebase comprehensively,” while diff-based reviews “focus on code changes only.”


Baseline manual code review

Diff-based manual code review

Scope

The whole codebase

Only the lines a change adds or alters

When to run it

New applications, major releases, onboarding legacy systems, compliance, post-incident analysis

Pull requests, commits, daily development, continuous validation

What it answers

What risk is already in production

What risk this change introduces

Cadence

At milestones and triggering events

With each change

The two work together. OWASP’s hybrid approach combines baseline reviews for high-risk components with diff-based reviews for routine changes, and escalates from diff-based to baseline review when significant security concerns are identified. A team that runs manual code review only on pull requests never examines the code it inherited.

What manual code review finds that scanners miss

The flaws reserved for manual code review share a trait: the code is syntactically correct and still wrong. Broken access control is the clearest family: OWASP notes that scanners, Static Application Security Testing (SAST) included, rarely detect it, because a permission check can exist in the code and still check the wrong thing for the wrong user. These entries from the Fluid Attacks Database show what a manual code review is actually looking for.

What the analyst reviews

Database weakness

What they check

Authorization and roles

005 — Privilege escalation

That a standard account cannot obtain administrative privileges. Linked requirement: 035, manage privilege modifications.

Secrets management

009 — Sensitive information in source code

That no credentials sit in the repository or its git history. Linked requirement: 156.

Object-level access control

013 — Insecure object reference

That a user cannot reach another user’s data by changing a key value. Linked requirement: 176.

Concurrency

124 — Race condition

That verification and use of an input happen atomically. Linked requirement: 337.

Business logic flaws belong on the same list. If a money transfer accepts a negative amount, every type check passes and the withdrawal becomes a deposit. No rule file describes that flaw, because the rule it breaks exists only in the business — which is why scanners rarely detect these flaws. A race condition behaves the same way: each line is valid, and only the order of arrival exposes the problem.

Apple’s 2014 goto fail bug (CVE-2014-1266) shows the same trait in a single line. A duplicated goto fail; line inside SSLVerifySignedServerKeyExchange, with no braces around the conditional, made the remaining certificate checks unreachable and the function return success, which let man-in-the-middle attackers spoof SSL servers. Security researcher David A. Wheeler’s analysis of the bug concludes: “Just about any manual review is very likely to have found this.” He also lists other controls that would have caught it, among them unreachable-code detection, mandatory braces and test coverage analysis, so manual code review works best as one control among several.

Reviewing AI-generated code

Manual code review of AI-generated code is now the highest-volume case, and the failure mode has changed with it. The code compiles, reads cleanly, and omits controls nobody asked for. OWASP’s Secure Coding with AI Cheat Sheet draws the line on accountability: “AI-generated code must have a human owner,” because “AI tools do not accept responsibility for the code they generate. The developer who accepts and commits the code does.”

Three things a manual code review has to check here that general review habits do not cover:

  • Dependencies that do not exist. OWASP notes that assistants “frequently suggest package names that do not exist on public registries” — an opening for an attacker who registers the hallucinated name.

  • Controls omitted by silence. The DevSecOps Guideline points at “Missing authorization and input validation, which models omit when the prompt does not mention them.”

  • Comprehension by the author. The same guideline sets a usable gate: “If the author cannot describe how it works, it is not ready to merge.” It also holds that generated code “needs at least the same scrutiny as code from an unknown contributor.”

An automated reviewer commenting on the change does not replace a manual code review here. OWASP is explicit that AI-generated review comments are no substitute for human review, and that “a human with accountability must still approve security-relevant changes.” Fluid Attacks’ analysis of how agent-driven development shifts responsibility reaches the same conclusion: execution scales, judgment does not.

How to measure whether the review worked

In manual code review, finding a flaw is not the outcome. An empirical study of 135,560 code review comments across OpenSSL and PHP, by researchers at the University of Melbourne and Singapore Management University (2023), found that reviewers raised security concerns in 35 of 40 coding weakness categories — and that 30% to 36% of those concerns were only acknowledged without a fix, while 18% to 20% went unresolved because reviewers and developers disagreed on the solution.

That is the number to manage. A manual code review program that reports findings and never checks closure is measuring activity, not risk. Three metrics describe the outcome instead: the share of findings remediated, the time from report to verified fix, and the share of reattacks that pass on the first attempt. Precision and recall describe how well the manual code review detects; these three describe whether it mattered.

Heartbleed shows why many readers is not the same as a review that worked. The flawed OpenSSL heartbeat code was introduced in December 2011 and shipped in OpenSSL 1.0.1 on 14 March 2012; the fix arrived in 1.0.1g on 7 April 2014 (heartbleed.com). CSO’s account notes that anyone could read the code and “presumably hundreds did,” and that the flaw “lurked undetected for two years” until Neel Mehta of Google decided to do a line-by-line audit of the OpenSSL code. At disclosure, Netcraft found the heartbeat extension enabled on 17.5% of SSL sites, around half a million certificates issued by trusted certificate authorities. That is why the three metrics above measure outcomes, not activity.

Manual code review versus automated pull request review

These are different jobs and conflating them creates false confidence. An automated pull request reviewer analyzes the lines a change adds; a manual code review analyzes what the change means for the system.

Fluid Attacks’ Peer Reviewer Assistant illustrates the automated half precisely. It reports “the vulnerabilities that the change introduces,” comparing against the merge base and reporting only on added lines, using SAST, SCA and secret scanning. It posts one summary comment per change, fails its status check when a CVSS 4.0 score crosses the “Minimum to break the build” threshold, and — importantly — does not block merges on its own unless the team makes the check required.

What it cannot do is decide whether a correctly written authorization change is the right authorization change. That remains a manual code review question, and alongside manual penetration testing it is why human techniques run together with the automated ones rather than one replacing the other.

Conclusions

Manual code review reads code for what it is supposed to do, which is where scanners rarely look. Fluid Attacks’ benchmark shows how large the gap can be for manual testing in general: 86.8% of the application’s risk exposure sat in flaws that no automated tool reported. Standards point the same way — PCI DSS v4.0.1 requires code review before release and NIST’s SSDF names it as a practice — but compliance is the floor, not the reason.

The practical version of manual code review is narrower than “review everything.” Run a risk-based code review to pick the targets, separate the baseline pass from the per-change pass, apply extra scrutiny to code a model wrote, and verify that each finding was actually closed. Secure coding practices give the reviewer the standard to check against; the reattack gives the organization the proof. A manual code review that ends at the report has done the expensive part of the work and skipped the part that reduces risk.

Frequently asked questions

What is the difference between code review and manual code review?

Code review is the general practice of assessing source code against standards, and it can be done by tools or by people. A manual code review is the human half specifically: a reviewer reading the code to find security flaws that depend on context, such as authorization logic, business rules and trust boundaries. Automated analysis checks the patterns it was configured to check.

Can manual code review be replaced by automated tools?

No. In Fluid Attacks’ benchmark of 36 third-party AppSec tools against a web application with 1,201 vulnerabilities, the third-party tool with the most true positives reached 21.6% recall and 4.0% of total risk exposure, while a pentester doing manual testing reached 89.6% recall at 100% precision. Tools cover breadth cheaply; manual analysis covers more of the flaws that carry the risk.

Does PCI DSS require manual code review?

Not specifically. PCI DSS v4.0.1 requirement 6.2.3 requires bespoke and custom software to be reviewed before release to production, and accepts manual processes, automated processes, or both. If the organization chooses manual review, requirement 6.2.3.1 adds conditions: the reviewer must not be the code’s author, must be competent in secure coding and review techniques, and management must approve the result.

How should AI-generated code be reviewed?

With the same scrutiny applied to a change from an unknown contributor. OWASP requires it to have a human owner who has reviewed and understood it, and flags three recurring problems: packages suggested by the model that do not exist, authorization and input validation omitted because the prompt did not mention them, and authors who cannot explain how the code works.

Does Fluid Attacks perform manual code review?

Yes. Its manual code review is the Secure Code Review service in the Advanced plan, where security analysts inspect source code in parallel with automated testing on the same repository. AI predicts high-risk files so reviewers start there, findings arrive with their file, line, CVSS v4.0 severity and a link to the weakness entry, and a pentester verifies fixes to manual findings when a reattack is requested.

Review the code before an attacker does

Our analysts run manual code review on your source code from the first commit, alongside the scanners, so the flaws a tool cannot reason about get found while they are still cheap to fix. Start free trial · Contact us.

Get started with Fluid Attacks' application security solution right now

Reduce risk without slowing delivery

Fast and accurate results from one continuous security program powered by AI, scanners, and pentesters.

Reduce risk without slowing delivery

Fast and accurate results from one continuous security program powered by AI, scanners, and pentesters.

Reduce risk without slowing delivery

Fast and accurate results from one continuous security program powered by AI, scanners, and pentesters.