For most of software engineering’s history, code review has rested on a simple assumption: Humans write code at roughly human speed. A developer makes a change. Another developer reads it. CI runs. Someone approves the pull request. The change moves toward production.
Coding agents are breaking that assumption.
GitHub says usage of Copilot code review grew 10× after launch and now accounts for more than one in five code reviews on GitHub. Cursor reports that AI edits per developer nearly tripled while median pull-request size more than doubled. Its data also shows the 75th percentile of lines added per PR increasing roughly 2.5× year over year.
The interesting part is not simply that AI is writing more code. AI is moving into both sides of the workflow.
Agents write the change. Other agents review it. They fix CI failures, respond to comments, validate tests, and increasingly carry a change toward merge with less direct implementation work from a human. GitHub’s coding agent already runs tests, linting, CodeQL, secret scanning and code review as part of its validation workflow.
At OpenAI, a recent description of its internal “software factory” goes further: multiple specialized review agents can examine changes from different domain perspectives while the coding agent continues working until the PR is green.
If this direction continues, one question becomes unavoidable: When agents write and increasingly review the code, what should humans actually review?
The old review math stops working
The traditional answer is: humans read the diff. That works when changes arrive at a rate humans can reasonably inspect. It works much less well when agents can produce larger changes, more frequently, across more repositories.
Cursor puts the problem plainly: coding agents did not invent large pull requests, but they made the old review economics fail faster. Its own data shows larger changes increasingly reaching engineering workflows.
There are three obvious responses.
One is to keep reviewing everything manually. That preserves the existing control model, but increasingly turns review into a throughput bottleneck.
Another is to let machines review everything and remove humans from most changes. That solves the throughput problem, but introduces a different one: accountability. Many engineering organizations still require human approval for production changes. Security-sensitive environments may become more cautious as AI authorship increases, not less.
The third path is more interesting:
Machines perform more of the continuous analysis. Humans retain accountability for the decisions that require judgement.
That changes the role of review.
It also helps to separate three layers of the workflow that are easy to blur together:
- Coding capability. Agents generate and modify software.
- Repository review. Agents review code, run tests, identify weaknesses, and propose fixes.
- Security decision context. The organization retains system context, previous security decisions, risk history, expected controls, policy, and evidence across changes.
The first two are advancing quickly. Neuralsec is being built primarily around the third, while integrating with the first two.
Approval and analysis are not the same thing
A pull-request approval is a surprisingly weak artifact. It tells us someone approved the change. It usually does not tell us:
- what they examined;
- which security assumptions were affected;
- whether authentication changed;
- whether sensitive data flows changed;
- whether a previous risk decision depended on the modified code;
- what analysis ran;
- what could not be assessed;
- or whether the reviewer spent thirty minutes reasoning about the change or five seconds writing “LGTM.”
As change volume grows, this distinction matters.
Imagine a small documentation and dependency-maintenance change. Security analysis can establish that it does not touch an exposed endpoint, authentication path, sensitive operation, trust boundary, infrastructure definition, known security finding or relevant control. A human may still need to approve it because organizational policy requires approval. But the reviewer should not have to rediscover all of that manually. The system can provide the evidence: These checks ran against this exact revision. No relevant security condition was identified.
Now consider another change. It modifies lines that were previously part of an accepted security-risk decision, changes authorization logic, and touches a service that handles personal data.
The review question should not be: Please read these 4,000 changed lines and decide whether they are safe. It can be much narrower: A previous security decision relied on these exact lines. This change modifies them. Does that decision still hold?
The human still owns the decision. But machine analysis has changed the economics of reaching it.
Policy decides. Evidence provides the focus.
There is an important boundary here. As security systems become more autonomous, it is tempting to say: The AI decides which changes require human review.
That is the wrong abstraction. The organization’s policy should determine the approval requirement. The security system should determine what evidence is relevant to that decision. A better principle is:
Policy decides the approval. The security system provides the evidence and focus.
This boundary also names a real tension. Engineering economics push toward less manual analysis per change, while audit and governance may still require accountable human approval. The answer is not necessarily to eliminate that approval, but to make it fast, targeted, substantive, and evidence-backed.
This matters for security as much as it does for governance. Once an automated gate influences where human attention goes, that gate itself becomes something worth evading.
An attacker may try to make a dangerous change appear routine. A coding agent may unintentionally optimize around whatever signals allow its changes to progress. A probabilistic model may also produce a persuasive explanation that is simply wrong.
The more authority the gate carries, the more important its evidence model becomes.
Models can reason. Evidence needs to survive them.
Modern models are remarkably useful for security work. They can trace unfamiliar code, explain a complex change, propose attack scenarios, synthesize context and communicate a review question far better than most traditional static-analysis output.
GitHub itself has moved Copilot code review toward an agentic architecture that retrieves broader repository context instead of considering only an isolated diff. Cursor makes essentially the same observation: AI review becomes more useful when it has the repository, recent changes, tests and explicit rules available as context.
Context matters. But explanation and evidence are different things. For security-sensitive change assurance, the authoritative record should be able to say things such as:
- these files changed;
- this endpoint is exposed;
- this operation handles sensitive data;
- this dependency version changed;
- these static-analysis checks ran;
- credential detection ran;
- this code was previously cited by a security finding;
- this accepted-risk decision relied on these lines;
- these controls are expected on this path;
- this detector could not run;
- this version of the system and threat model was used;
- this is who, or what, authored the change.
A model can reason over that evidence. It can explain why it matters. It can summarize the change, identify relationships humans might otherwise miss, and formulate the decision a human actually needs to make. But the evidence should remain inspectable and reproducible independently of the model’s prose.
Models reason. Evidence decides.
That distinction becomes more important, not less, as models improve.
If targeting attention is the product, context accuracy is the product
There is another consequence. A security scanner can tolerate contextual errors because its findings enter a triage queue. A system that tells humans where to focus their limited review capacity has a higher burden.
Suppose a security model repeatedly describes authenticated endpoints as unauthenticated because it does not recognize a framework-specific guard. The finding may look sophisticated. The explanation may be beautifully written. The recommendation may even be reasonable. But the context is wrong.
After enough mistakes, reviewers stop trusting the gate. And once that happens, the system has not conserved human attention. It has spent human trust.
This makes some fairly unglamorous engineering work strategically important:
- recognizing framework-specific controls;
- accurately resolving authorization boundaries;
- connecting findings to implementation evidence;
- maintaining trust-boundary context;
- knowing which sensitive operations actually execute;
- preserving the security decisions that depended on previous revisions.
Better models help. But better models cannot compensate indefinitely for a wrong understanding of the system underneath them.
The pull request is probably not the durable abstraction
Today, most of this discussion happens around pull requests. That makes sense. The PR is where code, discussion, CI and approval currently converge.
But security does not fundamentally care about a pull request. It cares about a change. The durable questions are:
- What changed?
- What does it affect?
- What security assumptions changed?
- Which previous decisions may no longer hold?
- What evidence should be retained?
- What does organizational policy require?
Today the answer may be attached to a GitHub PR. Tomorrow the change may originate from an autonomous task, an agent-produced patch, a deployment plan or another artifact we have not standardized yet.
That suggests an architectural distinction: PR review is an integration. Change assurance is the capability.
There is no need to prematurely abstract every engineering workflow around hypothetical future artifacts. But designing the security decision itself around the concept of a change rather than permanently around a PR leaves room for the development workflow to evolve.
The best security review may happen before the code exists
There is an even more interesting implication. If agents increasingly perform implementation, waiting until the completed diff exists may already be too late.
The same system context used to review the change can be useful while the agent is creating it. Before modifying an authorization flow, for example, an agent could know:
- this endpoint crosses a trust boundary;
- resource ownership must be enforced;
- this service already has a standard authorization pattern;
- a previous vulnerability here was caused by trusting client-supplied roles;
- an accepted-risk decision depends on this control remaining in place.
That creates a different loop:
- Observed weakness
- Failed or missing control
- Security principle
- Engineering or agent guidance
- Future change
- Change assurance
Security no longer only detects recurrence. It helps make recurrence less likely.
This may be one of the bigger changes that agentic engineering creates for Product Security. The security system stops being purely downstream of development. It becomes context available to the development system itself.
Humans move upward
None of this necessarily means humans disappear from review. They may remain required for every production change in some organizations. What changes is what we ask them to spend attention on.
Less: Did you manually reconstruct everything this diff could possibly affect?
More: This change modifies an authorization control that protects a sensitive operation. The existing policy requires review. Here is the execution path, the previous security decision, the affected system context and the evidence produced. Does the control still satisfy its intent?
That is a much better use of human judgement. Humans are particularly valuable for questions involving:
- architecture;
- product intent;
- exceptions;
- ambiguous behavior;
- residual risk;
- material risk acceptance;
- business tradeoffs.
Machines are increasingly good at continuously collecting and connecting the evidence underneath those questions.
The review should make the next change safer
There is one final opportunity. Most security workflows end when the ticket closes. That wastes what was learned.
If an organization repeatedly discovers missing ownership checks, unsafe trust-boundary transitions or weak authorization controls, the output should not only be more closed findings. It should be a stronger engineering system. The recurring weakness can become:
- a secure pattern;
- a policy check;
- repository guidance;
- targeted developer training;
- coding-agent instructions;
- a control expected by future change assurance.
Every finding and every review becomes input to the next one.
Every finding and every change should make the next one safer.
That is the loop drawn earlier, closed: observed weakness, missing or failed control, security principle, engineering or agent guidance, future change, change assurance. It is how Product Security moves from endlessly processing findings toward strengthening how future software is created — a very different model from scanning an endless stream of newly generated code and hoping humans can keep up.
The question is no longer whether AI reviews code
That transition is already underway. GitHub is making code review increasingly agentic and context-aware. Cursor is building review around repository context. Agentic development environments increasingly run tests, security checks and remediation before requesting human review.
That is good news. Generic code review, test execution, and even parts of vulnerability remediation are becoming increasingly automated. But repository-aware review does not remove the need for a security decision layer around the change.
A reviewer may understand the repository and the diff. Product Security also needs to understand what the organization already knows about that code: the trust boundaries it crosses, sensitive operations it affects, controls expected there, previous findings and mitigations, accepted-risk decisions, relationships with other services, and the policy that determines what evidence or approval is required.
The better coding agents and repository-level reviewers become, the more valuable persistent organization-level security context becomes.
The question is no longer whether AI can review code. It increasingly can.
The harder question is what security context should govern the change, what evidence should survive the review, and which decisions should remain accountable to humans.
The answer will probably not be another generic approval button. It will require continuously maintained system context, reproducible evidence, organizational policy, and a clear boundary between what machines can analyze and what humans are still expected to decide.
The future of code review may therefore be less about humans reading every line. And more about giving humans the evidence to make the decisions only humans should own.
We’re building Neuralsec around these ideas. If you’re rethinking security review for AI-accelerated development, we’d be happy to compare notes.
