In short
The person who approved the change is accountable for its bugs, even if Claude Code or another AI coding agent wrote every line. So write down which changes still need a person to read them, and what an approval means for the rest.
AI coding agents now write code faster than people can review it, and a person is still responsible for what ships.
I led R&D teams for 20 years, and each number here comes with its date and a link to its source.
I start with why nobody reads all the code and whose name the record keeps, then who is responsible when the code breaks.
The last sections cover which changes still need a person, and how to know afterwards that the code lasted.
Do developers check AI-written code before they commit it?
In Sonar's 2026 survey, only about half of developers said they always check AI-assisted code before they commit it.
Sonar makes tools that check code. In January 2026 it published its State of Code Developer Survey of more than 1,000 developers. In that survey, 96% of the developers said they don't fully trust that AI-generated code works correctly. Only 48% said they always check their AI-assisted code before they commit it.
The survey comes from a vendor, and the developers answered about their own habits. Still, the gap between the 2 numbers is large. So don't treat an approval as proof that someone read the code.
Why is code review the bottleneck when AI coding agents write the code?
Because AI coding agents write code faster than people can review it, and the extra code waits in a queue for review.
Fiona Chen and James Stratton, 2 researchers at Harvard, measured that queue in a working paper on bottlenecks in software production. They looked at more than 700,000 workers at more than 650 companies, from January 2021 to August 2026. Their data comes from an engineering analytics platform. Other researchers haven't reviewed the paper yet, and the numbers here are from the version dated November 7, 2026.
Many of these companies already used AI assistants. When they added AI coding agents as well, their lines of code rose by about 44%, the 2026 paper found. The number of resolved issues rose by only about 14%, and the researchers say that even this result is only borderline significant, so their data does not clearly confirm it.
The extra code went into a queue. In the 2026 Harvard paper, the time from a request for review to an approval rose by about 56% after AI agents arrived.
In the same paper, more than 8 in 10 reviews went to someone who already knew that code. When a senior engineer wrote a change, another senior engineer reviewed it in about 3 reviews out of 4. One engineer told the researchers that on one project, only one senior engineer was allowed to approve changes. "He was so bandwidth constrained that he could only review my code once a week."
I think that queue explains much of Sonar's 48%. Nobody decides to stop reading. The queue gets long, the tests pass, and someone clicks Approve.
Whose name is on a commit that Claude Code wrote?
The name on the commit depends on the setup, and the approver of the pull request may be the only human named in the record.
On your own laptop, the commit carries your name as the author. Claude Code's documentation on attribution says that by default, Claude Code only adds a line at the end of the commit message. That line names Claude as a co-author.
In the cloud, the name depends on how the agent runs:
- A scheduled task runs as a full Claude Code session in the cloud. What it does through your connected GitHub account appears as you, so its commits and pull requests carry your GitHub user.
- When Claude Code's cloud runner configures Git, Claude is the author. The person who started the session is added as a co-author only when the runner is given that person's details.
- The Claude Code GitHub Action works as the Claude GitHub App, under its own identity. An agent with its own account can open a pull request under its own name.
When a person approves the pull request, the record keeps that name with a date. GitHub's record of a pull request review holds who reviewed it, its state (for example, approved) and when the review was submitted.
The Linux kernel has written its rule down. Its documentation page on AI coding assistants says: "AI agents MUST NOT add Signed-off-by tags. Only humans can legally certify the Developer Certificate of Origin (DCO)." That tag is the line where a kernel developer certifies a change.
The same page lists what the human who submits the code is responsible for. The first item is "Reviewing all AI-generated code", and the last is "Taking full responsibility for the contribution".
The team that builds Claude Code says the same about its own work. In its October 2026 post on how the team does code review, it writes: "A person is accountable for every change that ships, whoever typed it."
So Claude Code can write the code and open the pull request, and a person is still responsible for it.
When AI code breaks, who is responsible?
The first person held responsible is the one who submitted or approved the change, and the team and the leader share the responsibility.
Amazon gave a public example in February 2026. A report in the Financial Times linked a short AWS outage to Kiro, Amazon's own AI coding tool. Amazon answered on its own news site, Amazon News. It wrote that the interruption "was the result of user error, specifically misconfigured access controls, not AI as the story claims."
That sentence points to a person. I don't think that's automatically unfair, because somebody has to be responsible for what ships.
But the responsibility can't stop at one person. The engineer is responsible for the merge, and the team that owns the service has to keep it running. And a leader is responsible for the pace. If you ask for twice the code and give reviewers the same hours, you have already decided that some of it won't get read.
The Claude Code team calls its rule for small and medium changes "You land it, you own it", where to land a change means to merge it. If something still goes wrong, the post says, "it's a team norm that you usually fix it." Then it adds: "It isn't blame. Owning a fix means you have the most context; incident reviews look at the system."
Should you read every line of AI-generated code?
No. Nobody can, and the Claude Code team says that asking whether a person read the code is only a rough test anyway.
The team says the question "did a human read the code?" is "an imprecise proxy". It only roughly answers what you really want to know: what could go wrong with this change, and which check will catch it.
From June to September 2026, the team more than doubled the pull requests it merged into Claude Code. The share of merged pull requests it had to undo fell by more than 40%. That's the team's own report about its own product.
A researcher, Martin Monperrus, goes further in his 2026 paper, The End of Code Review. He cites earlier work that developers at large companies spend 10 to 15% of their working hours reading and commenting on others' code. For most changes, he writes, "agent sign-off is sufficient, and requiring more is waste."
I think that's more than half right. An agent can do most of the reading, but it can't take responsibility for the change.
An AI reviewer helps, and how much depends on who measured it:
- In 2025, Microsoft reported that 5,000 repositories using its AI reviewer completed pull requests 10 to 20% faster, measured by the median time.
- The 2026 Harvard paper found that 79% of the companies had adopted AI code review tools. People still wrote the large majority of reviews, and the queue was still there.
- A 2026 study by Suzhen Zhong, Shayan Noei, Bram Adams and Ying Zou covered about 1 million reviewed pull requests in about 200 open-source projects. In some projects, reviews that AI agents started, or that involved several AI agents, reached a decision faster. Review quality was not better.
So use an AI reviewer. The Claude Code team still has one rule that I'd copy: "An agent's approval never counts as a person's."
Which AI-written changes still need a person to read them?
Let risk decide which changes need a person, not who or what wrote the code.
The Claude Code team writes: "The change sets the tier, not the author." Its post sorts every change into 3 levels:
| Level of risk | Example changes | People who must approve |
|---|---|---|
| Low | Documentation, text, internal-only features, new code that is disabled | None, once automated review and security checks pass |
| Medium | Ordinary product changes, and sensitive areas such as caching | 1 |
| High | The highest-risk code, and a small set of paths that always need 2 people | 2 |
The same post names the code that always needs a person: login, billing, build and release workflows, and installers.
Copy those levels or write your own, but write them down. Without a written rule, your team's rule is whatever the last person did.
For every change that no person reads line by line, redefine what an approval means. Before you approve a change, be able to say what it does, how it was tested, what could go wrong and how to undo it. The Claude Code team's pull request template asks how the change was tested and how to undo it. The post also says what to do when you can't say those things. "If you can't say what the checks would miss, ask for a real review rather than a quick approval."
Approving a change used to mean that you had read the code. Now it has to mean that you understand the change and take responsibility for it.
How do you know AI-written code lasted in production?
Look at what happened to the code after the merge: how long it waited for a person, and whether it was undone or fixed.
The Claude Code team watches much of that. It tracks how long a pull request waits for a person, and it treats undone changes and incidents as the safety check. The post says: "if they rise, we haven't saved human time, we've only moved it."
You can trace the fixes by hand for your own team:
- Pick one fix that was made to production code.
- Search the change history for the pull request that added the lines the fix changed.
- Write down who or what wrote that pull request, and who approved it.
That's fine for 10 fixes, and you'll learn a lot from them. For a whole year of AI-written code, it's a lot of work. The article on measuring developer productivity when AI writes code compares review speed with the approved changes that were fixed later.
I founded Aidealy, which makes software that measures the work engineering teams ship. Its ranking of engineers, the Aidealy Productivity Rank, works this way. When code has to be fixed after the merge, Aidealy traces the fix back to the pull request that added the line. It names the person who wrote it and the person who approved it, even weeks later. Every line that shipped is labeled as written by AI or by a person, from the records Claude Code and Cursor keep. The rank makes no exception for lines the AI wrote. When such a line has to be fixed, points come off the author of the pull request, and the approver shares that cost. Approving a colleague's change earns credit, and keeping a colleague waiting costs points.
What should your team write down about AI code review this week?
Write one page with 3 things on it.
- The code that always needs a person, such as login and billing.
- The 4 things an approver must be able to say about every other change.
- The 2 numbers you will check afterwards: how long pull requests wait for a person, and how many changes had to be undone.
By hand, both numbers mean going through your pull requests one by one.
One result would change my mind: a team where AI reviews and merges everything, and the number of fixes after the merge still drops. Until I see that, if your team cannot say what a change does and how to undo it, a person should read it.
Sources
- Sonar, "State of Code Developer Survey", press release, January 8, 2026: https://www.sonarsource.com/company/press-releases/sonar-data-reveals-critical-verification-gap-in-ai-coding/
- Fiona Chen and James Stratton, "Artificial Intelligence in the Firm: Bottlenecks in Software Production", Harvard working paper, version of November 7, 2026: https://fion.ac/jellyfish.pdf
- The Linux kernel documentation, "AI Coding Assistants": https://docs.kernel.org/process/coding-assistants.html
- Claude Code documentation, the attribution setting: https://code.claude.com/docs/en/settings-reference#attribution
- Claude Code documentation, "Automate work with scheduled tasks": https://code.claude.com/docs/en/routines
- Claude Code documentation, "Claude Code GitHub Actions": https://code.claude.com/docs/en/github-actions
- Claude Code documentation, the cloud runner's Git setup: https://code.claude.com/docs/en/self-hosted-environments-deploy#let-the-runner-configure-git
- GitHub documentation, the pull request review record: https://docs.github.com/en/rest/pulls/reviews
- Addy Osmani, Morgan Westlee Lunt and Qing Wang, "How the Claude Code team does code review", claude.dev, October 15, 2026: https://claude.dev/blog/solving-code-review-at-anthropic/
- Amazon News, "Correcting the Financial Times report about AWS, Kiro, and AI", February 20, 2026: https://www.aboutamazon.com/news/aws/aws-service-outage-ai-bot-kiro
- Microsoft, "Enhancing Code Quality at Scale with AI-Powered Code Reviews", July 14, 2025: https://devblogs.microsoft.com/engineering-at-microsoft/enhancing-code-quality-at-scale-with-ai-powered-code-reviews/
- Martin Monperrus, "The End of Code Review: Coding Agents Supersede Human Inspection", arXiv, June 11, 2026: https://arxiv.org/abs/2606.13175
- Suzhen Zhong, Shayan Noei, Bram Adams and Ying Zou, "From Human-Centric to Agentic Code Review: The Impact of Different Generations of Generative AI Technology on Review Quality", arXiv, July 14, 2026: https://arxiv.org/abs/2607.13196

