All articles

Article · 10-min video

Who is accountable for bugs from AI coding agents?

Oren Keinan, founder of Aidealy ·

By pressing "Play on YouTube", you agree to load this video from YouTube, a Google service. Google then receives data such as your IP address and may store data in your browser.
Details in our Cookie Policy and Privacy Policy.

Also available with audio in Arabic, French, German, Hebrew, Italian, Japanese, Korean, and Portuguese: choose one in the player's settings.

Watch on YouTube (Opens in a new tab)More from Oren Keinan on YouTube (Opens in a new tab)Read the transcript

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 riskExample changesPeople who must approve
LowDocumentation, text, internal-only features, new code that is disabledNone, once automated review and security checks pass
MediumOrdinary product changes, and sensitive areas such as caching1
HighThe highest-risk code, and a small set of paths that always need 2 people2

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:

  1. Pick one fix that was made to production code.
  2. Search the change history for the pull request that added the lines the fix changed.
  3. 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.

  1. The code that always needs a person, such as login and billing.
  2. The 4 things an approver must be able to say about every other change.
  3. 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

Watch the video on YouTube

More from the blog

Transcript

Show the full transcript

0:00 When Claude Code writes it, whose name is on it?

You probably approved code this week that nobody read. Not even you. If it breaks, the approval that people will find is yours. So you have to decide which changes still need a person, and what your approval means. That's what this video is for. Who's responsible when AI-generated code nobody read causes production bugs? The person who approved it, even if Claude Code wrote every line.

And the leader who set the pace. Sonar makes tools that check code, and it published a survey of developers in January 2026. Of those developers, 96% said they don't fully trust the code AI writes. And only 48% said they always check it before committing. I know the title sounds harsh. Sonar sells those tools, and I build software that measures engineering work.

Every number in this video is dated and linked below.

0:53 Why nobody can read all the code from AI coding agents

Nobody can read all of it anymore, because AI coding agents write code faster than people can review it. And 2 researchers at Harvard have now measured that. Fiona Chen and James Stratton looked at more than 700,000 workers at more than 650 companies. Their data comes from an engineering analytics platform. It's still a working paper, so other researchers haven't reviewed it yet.

The version I'm using is dated November 7, 2026. When these companies added AI agents in addition to the AI assistants they already had, they got about 44% more lines of code. The number of resolved issues went up by about 14%, and the researchers call even that borderline. The extra code went into a queue. After AI agents arrived, the time from asking for a review to getting an approval went up by about 56%.

And those reviews don't spread evenly. More than 8 in 10 reviews go to someone who already knows that code. And when a senior engineer writes a change, another senior engineer reviews it about 3 times out of 4. One engineer told the researchers that on their project, only one senior person could approve changes. The engineer put it this way: "he was so bandwidth constrained that he could only review my code once a week."

I think that queue is what's behind Sonar's 48%. Nobody decides to stop reading. The queue gets long and the tests pass, so you click Approve.

2:23 Your name on the commit: Git, Claude Code and the Linux kernel's rule

[On screen: illustrative example, not real data]

The commit usually records a person as the author, whoever typed the code. On your own laptop, the commit carries your name as the author. By default, Claude only gets a line at the bottom saying it co-authored the change. In the cloud, it depends on the setup. Sometimes the commit carries your GitHub name. Sometimes Claude is the author and you're the co-author.

And an agent with its own account can open the pull request under its own name. Then the commit doesn't show your name. But when a person approves the pull request, that name is saved with a date next to it. That may be the only human name in the record. The Linux kernel has written this down. Its current documentation has a page about AI coding assistants, and it says "AI agents must not add Signed-off-by tags."

That's the line where a kernel developer certifies a change, and only a person can add it. The same page lists what the human who submits the code is responsible for. The first item is "reviewing all AI-generated code." The last one is "taking full responsibility for the contribution." In a post from October 2026, the team that builds Claude Code says the same about its own work.

"A person is accountable for every change that ships, whoever typed it." So Claude Code can write the code and open the pull request. A person is still responsible. And you feel that most on the day something breaks.

3:48 When AI code breaks, who is responsible?

When AI code breaks, the first person held responsible is the one who submitted or approved it. Amazon gave us 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 news site that the outage was "the result of user error," "not AI as the story claims."

But look at who that sentence points to. It points to a person. And I don't think that's automatically unfair. Somebody has to be responsible for what ships. But it 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've already decided that some of it won't get read. The Claude Code team has a short saying for whoever merges a small or medium change: "you land it, you own it." And they add this. "It isn't blame." "Owning a fix means you have the most context; incident reviews look at the system."

4:54 Should you read every line? What AI code review can and can't do

You can't read every line, and the Claude Code team says that's the wrong test anyway. They say that asking whether a human has 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, they more than doubled the pull requests they merged into Claude Code.

And the share they had to undo fell by more than 40%. That's their own report about their own product. A 2026 paper by a researcher named Martin Monperrus goes further. It's called "The End of Code Review." It says developers at large companies spend 10 to 15% of their working hours reviewing code. And it says that for most changes "agent sign-off is sufficient, and requiring more is waste."

I think that's half right. Well, more than half. 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 you ask. In 2025, Microsoft reported that 5,000 repositories using its AI reviewer finished pull requests between 10 and 20% faster. The Harvard paper found that about 8 in 10 companies already use AI review tools, and the queue is still there.

And a 2026 study looked at about 1 million open-source pull requests. In some projects reviews started by AI agents reached a decision faster, but review quality wasn't better. So use an AI reviewer. It'll find a lot of problems. The Claude Code team still has one rule that I'd copy. "An agent's approval never counts as a person's."

6:34 Which changes still need a person

Risk decides which changes still need a person. That's the rule at the Claude Code team. Their wording is short: "the change sets the tier, not the author." They use 3 levels. A low-risk change like documentation needs no person once the automated checks pass. An ordinary product change needs 1 person. And the riskiest code needs 2. Copy those levels or create your own, but write them down.

Without a written rule, your team's rule is whatever the last person did. And for everything a person doesn't read line by line, change what an approval means. Before you approve a change, you should be able to say what it does and how it was tested. You should also know what could go wrong and how to undo it.

The Claude Code team has a sentence for the day you can't say that. "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.

7:36 How to know the code lasted

You know the code lasted by looking at what happened to it after the merge. The Claude Code team watches exactly that. They track how long a pull request waits on a person, and they treat undone changes and incidents as the safety check. Their sentence is this. "if they rise, we haven't saved human time, we've only moved it."

You can do this by hand for your own team. Take a production fix. Go back through the change history to the pull request that added the broken line. Then write down who wrote it 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.

[On screen: illustrative example, not real data]

I'm the founder of Aidealy. We make software that measures the work engineering teams ship. And 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. And the rank makes no exception for lines the AI wrote. If the AI wrote the line and it's your pull request, points come off when it has to be fixed. And the approver shares that cost. Approving a colleague's change earns credit, and keeping a colleague waiting costs points.

9:02 The 3 things to write down this week

This week, write down a single page with 3 things on it. Start with the code that always needs a person. The Claude Code team's list has login and billing, plus build and release files and installers. Next comes what an approver has to be able to say about everything else. And last, write the 2 things you'll check afterwards.

How long a pull request waits for a person, and how many changes had to be undone. Here's what would change my mind. A team where AI reviews and merges everything, and the fixes after merge still go down. I think an approval should mean that you understand the change and take responsibility for it. If your team can't say that about a change, a person should read it.

The sources I used are all linked below. If you want to keep going, pick one of the videos on the screen now. Or subscribe for the next one.

Ask Aidealy yourself.

In the free demo, you ask the real Aidealy chat app about a fictional company's engineers, AI agents and code. Or tell us what you're trying to figure out, and we'll get you set up to answer it on your own R&D: your engineers, your AI agents, and the code they ship together.