# AI Writes Code Faster Than Your Team Can Review It

Andrew Norrish, Sourcegraph | AI Engineer NYC 2026 | 18:57

Source: https://www.youtube.com/watch?v=-X3yXTwGs9A
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/ai-writes-code-faster-than-your-team-can-review-it
Published: 2026-11-02
Tags: agents, coding-agents, reliability, search

## TL;DR
- AI-driven development has moved the bottleneck from writing code to reviewing larger volumes of AI-generated code.
- Unreviewed AI code is contributing to more frequent, longer, and more expensive incidents that fall on SRE and platform teams.
- Code search, code graphs, monitoring, and bulk changes can help SREs investigate, prevent, and remediate problems across large codebases.

## Summary
Andrew Norrish argues that AI coding tools have increased developer output faster than teams can safely review it. Pull requests are larger and more numerous, while developers often lack enough context to judge AI-generated changes in large or legacy codebases. Some code is merged without meaningful human review, and incidents then reach SREs who may also lack context about the affected code. Hiring more SREs does not keep up with the incident volume. Norrish says AI works better in bounded areas such as vulnerability remediation, security scanning, migrations, and incident response. SRE and platform teams already operate these semi-autonomous workflows, so they can both measure the risks from AI code and apply AI with tighter controls. He presents Sourcegraph's code graph, code search, code intelligence, monitoring, and bulk-change features, then describes customer workflows for security triage, root-cause analysis, and code-review evaluation across a large monorepo.

## Key ideas
### AI coding has shifted the bottleneck to review
[01:28](https://www.youtube.com/watch?v=-X3yXTwGs9A&t=88s)
Norrish describes a pattern he hears from customers: AI and agentic tools increase developer velocity, codebases grow, and businesses expect releases to increase with tool usage. The constraint is no longer how quickly a person can type code. It is how quickly people can review the larger volume of code that AI produces. Pull requests have grown in both count and size, while developers face pressure to clear the review queue. AI-written changes can lack the organization-wide context needed for production code, especially in large or legacy codebases.

### Unreviewed AI changes are reaching production
[03:03](https://www.youtube.com/watch?v=-X3yXTwGs9A&t=183s)
Norrish says developers may prioritize moving through an expanding pull-request queue over deciding whether they fully trust each change. Code generated without the context of the wider codebase can be merged without a human meaningfully examining it. Breaking changes then get missed. He connects the rise in AI usage with more AI-caused incidents, including problems that cross service boundaries and are difficult to trace back to their source.

### More SRE hiring does not match the incident growth
[03:44](https://www.youtube.com/watch?v=-X3yXTwGs9A&t=224s)
The resulting incidents are more frequent, take longer to resolve, recur, and cost more, according to Norrish. Responders may have no runbook and may be working with code that no human has previously examined. Leadership may respond by hiring more SREs, but Norrish says demand for the role is already high and incidents are increasing faster than organizations can hire people to handle them. Manual approaches such as scanning commits are slow and prone to errors.

### Large organizations need more context than AI often has
[05:02](https://www.youtube.com/watch?v=-X3yXTwGs9A&t=302s)
Norrish says AI still hallucinates and often lacks the context needed in large, complex, or legacy environments. When an entire codebase cannot be cloned locally, an agent has to make judgments from a partial view. Developers also spend more time reviewing AI code because they do not fully trust it, yet Norrish cites a gap between that distrust and actual verification. He links this situation with declining quality, security, and comprehension of generated code.

### Bounded workflows are where AI works better
[09:46](https://www.youtube.com/watch?v=-X3yXTwGs9A&t=586s)
Norrish is more positive about AI when its work is limited to a well-defined area with the context needed to meet organizational and compliance requirements. He gives vulnerability remediation, security scanning, large-scale migrations, and prototypes built by non-developers as examples. SRE and platform teams already run semi-autonomous processes such as remediation tooling, incident runbooks, and CVE monitoring. Those teams can use AI inside these established boundaries while also measuring its failure rate through the incidents it produces.

### A code graph can provide context for investigation and prevention
[12:09](https://www.youtube.com/watch?v=-X3yXTwGs9A&t=729s)
Sourcegraph's platform includes a full code graph, code search, and code intelligence for navigating large codebases. Norrish describes these components as a context engine for agents. For SRE work, he groups the uses into investigation, prevention, and remediation. Deterministic search can query repositories, branches, and commits. A deeper search feature can return answers with citations. Monitoring can alert teams when risky or non-compliant patterns are committed.

### Bulk changes let one fix reach every affected repository
[14:28](https://www.youtube.com/watch?v=-X3yXTwGs9A&t=868s)
Finding the root cause is only part of the problem when the same issue appears in many repositories. Norrish says Sourcegraph can identify all affected areas and apply bulk changes across an organization's repositories. This addresses the situation where a fix in one repository also needs to be applied to hundreds or thousands of others. Relying on separate teams to make each change can leave fixes incomplete or delayed.

### Customer workflows connect production signals to source code
[16:03](https://www.youtube.com/watch?v=-X3yXTwGs9A&t=963s)
Norrish gives a customer example involving more than 5,000 developers. When downtime or a sharp rise in errors occurs, an internal root-cause agent takes logs and traces, identifies the production branch or tag, searches Git history for the triggering commit and author, and can either revert and redeploy or send the investigation to SREs. He also describes Sourcegraph's internal security triage workflow and a customer using a read-only code-finder agent to search historical branches in a large monorepo.

## Notable quotes
- "That bottleneck is now very clearly with how quickly humans can review the code that the AI is now writing." (03:03)
- "It's only a matter of time before breaking changes are missed and merged by code reviewers." (03:23)
- "The rise of incidents is quickly starting to outpace the ability to hire people to resolve them." (04:24)
- "AI is winning a whole lot more though when you can narrow its focus to well-bounded domains with all of the necessary context to meet your organizational and compliance requirements." (09:47)
- "Investigation, prevention, and remediation." (13:09)

## Tools & references mentioned
- Sourcegraph
- HackerOne
- Anthropic
- AI agents
- code search
- code graph
- CVE monitoring
- Git

## Who should watch
- Your team is reviewing more AI-generated pull requests than it can comfortably assess, especially in a large or legacy codebase.
- Your SRE or platform team is handling incidents caused by changes that lack clear ownership, history, or documentation.
- You are designing bounded AI workflows for security triage, incident response, migrations, or repository-wide remediation.

## Editor's note

Andrew Norrish says AI-generated changes can reach production without meaningful human review, leaving SREs to investigate incidents in code that no person has examined. Kitaru records each model call and tool result from an agent run, then replays the run with those same inputs and responses after a prompt, model, or code change. That gives teams a repeatable way to examine an agent failure instead of relying on production symptoms alone.

Written by the AIE Talks editors (the Kitaru team), not by the speaker.

## Related talks

- [Don't get one-shotted: Use AI to test, review, merge, and deploy code](https://aietalks.com/talks/dont-get-one-shotted-use-ai-to-test-review-merge-and-deploy-code) (Tomas Reimers, Graphite, 05:45)
- [How to Kill the Code Review](https://aietalks.com/talks/how-to-kill-the-code-review) (Ankit Jain, Aviator, 16:26)
- [AI Coding Agents Are Breaking Big Codebases](https://aietalks.com/talks/ai-coding-agents-are-breaking-big-codebases) (Dan Adler, Sourcegraph, 12:23)
- [AI Writes More PRs. Who Validates Them?](https://aietalks.com/talks/ai-writes-more-prs-who-validates-them) (Ali-Reza Adl-Tabatabai, Sonar, 11:34)
- [Why Humans Can't Keep Up With AI-Written Code](https://aietalks.com/talks/why-humans-cant-keep-up-with-ai-written-code) (Tariq Shaukat, Sonar, 16:35)
