The speed of development in large open-source projects has always been limited by code review, not code generation. Even as coding agents get better at writing code, they do not accelerate development on their own. This is especially true of patches to the Linux kernel. Without a way to build trust in proposed changes, more generated code simply piles up in front of the same small group of human maintainers. Some of those patches are solid changes, just written faster; many others are plausible-looking "AI slop" sent by contributors who do not fully understand the systems they are modifying. And the influx of AI-generated security reports, many of which are duplicates or inaccurate, only adds to maintainers’ load.
Linux runs billions of Android phones, most cloud providers, and nearly every supercomputer. It spans more than 35 million lines of code, and over 85,000 changes land every year. Automated build bots and fuzzers like Syzkaller catch build errors and crashes, but code review has always been the main way to guarantee the stability and safety of the kernel. Every day, maintainers read hundreds and hundreds of proposed patches by hand to catch memory leaks, deadlocks, race conditions, and security bugs.
To help maintainers handle the load and catch bugs before they land, the Google AI & Infrastructure team built Sashiko, an open-source, agentic code review system powered by Gemini. We named the project after the Japanese word 刺し子, a stitching technique for artistically reinforcing worn cloth, and donated it to the Linux Foundation earlier this year.
In this blog, we cover the problem Sashiko was designed to solve, how it works, what the data shows, and what we learned from building and running it in the wild.
Reviewing a change in a complex code base is objectively hard, both for humans and LLMs. It often requires a deep understanding of how the system works in general, well outside the proposed change. In fact, it’s pretty common to see patches that engineers claim perfectly solve the problem, but if they were to be merged, would actually introduce even worse problems (albeit subtle). Traditionally, only experienced maintainers have been able to spot and prevent these issues. The same is true for agentically generated code.
To verify the correctness of a change, a potentially large number of invariants should be proven, which is often a much larger and harder task than developing the change itself. This is true for both human and agentic reviewers. However, LLM-based reviewers have some unique properties, both positive and negative:
To avoid these failure modes, Sashiko separates finding candidate bugs from verification of those bugs, and requires each pass to record what it ruled out:
Notes on each step:
Gather context and plan: Sashiko first pulls in the code around the diff (modified functions, struct definitions, and direct callers) and loads the subsystem's domain guides, so the changed lines are never judged in isolation. A planner then decides which specialist passes are needed (skipping hardware checks on pure software code, for example) and sets a reasoning budget for each pass based on patch complexity.
Parallel specialist sessions: Up to seven specialist sessions run in parallel, each focused on a single class of problems: commit intent, implementation match, control flow, resource lifetimes, locking, security, and hardware. Giving each pass a single focus prevents one type of bug from crowding out another. Each session searches and reads the repository with git tools (averaging about 100 tool calls per review) and outputs two lists: concerns it believes are real, and candidate concerns it investigated and ruled out, along with the code that supports that conclusion.
Triage: A lead verifier audits those two lists together. Clear-cut bugs already proven by the code in front of it pass straight through; dismissals proven by a local check are dropped. Everything else deserves additional investigation. Crucially, that includes not only contested bugs where specialists disagreed, but also shaky self-dismissals — cases where a specialist spotted a real bug and dismissed it by assuming, without proof, that some unseen caller or lock would prevent it.
Per-bug deep checks: Instead of checking all difficult cases in one shared prompt, Sashiko gives each difficult case its own verification agent that runs in parallel. Each agent gets one specific question to answer with git tools under a symmetrical rule: Neither a bug claim nor a dismissal is accepted without concrete code proof across all call sites. If a specialist talks itself out of a real bug based on a false assumption, this step catches it and promotes it back to a real finding.
Review report: Sashiko generates a report that sounds like a human maintainer asking questions about the proposed change, matching the style expected on a Linux mailing list.
All this happens at no cost for developers. Deep agentic reviews at scale require a substantial token budget. If developers had to pay for them with their own API keys, many important contributors would be pushed away. Instead, Sashiko reviews patches sent to public Linux kernel mailing lists, and Google runs the service at sashiko.dev. Everything runs in the open: every prompt, tool call, reasoning step, and ruled-out bug is public. The project initially used the open-source Linux review prompts started by Chris Mason, and more than 100 contributors, including prominent kernel maintainers and engineers, have since helped to improve prompts and Sashiko itself. Recently, Sashiko switched to a different prompt system that combines per-tree or per-version auto-generated notes on code with subjective maintainers notes, which contain directions and instructions from maintainers that can’t be derived from the code.
The real test of an automated reviewer is whether maintainers pay attention to the reports it sends out, and whether those reports track actual software quality. Seven months of Sashiko production data from the kernel mailing lists give a clear picture of both these questions.
It is part of the daily workflow. Sashiko completes roughly 1200 reviews a day across over 100 kernel mailing lists. It sends review emails only to lists whose maintainers opt in, and already over 70 of them have done so. Developers also engage directly with the reports: More than 1500 kernel developers have replied on the mailing lists, and their pushback on false alarms has directly driven improvements to Sashiko's prompts and verification engine. In fact, LWN.net recently wrote that Sashiko has already become an important part of the kernel's development process and was the top bug reporter of issues in the 7.2 release cycle.
It prevents new bugs and uncovers old ones. When Sashiko flags a bug in a proposed patch, the author typically fixes it in the next revision before the change is ever merged. Many developers run Sashiko locally or in corporate private instances. The bugs that Sashiko helped to prevent leave no trace in the git commit log, making them hard to count directly. What can be counted are fixes for preexisting bugs that Sashiko finds and reports as a byproduct of reviewing new changes: Sashiko is cited in over 2000 mainline kernel commits and in over 500 of this year's official Linux kernel CVEs, spanning drivers, core kernel code, networking, GPUs, memory management, and virtualization.
Fewer bugs are slipping into mainline releases. Across the 18 kernel releases prior to Sashiko (Linux 6.2 through 6.19, covering 254000 commits), an average of 3.4% of merged commits required a follow-up fix within 60 days. Since Sashiko rolled out, that 60-day fix rate has fallen to 2.8% in Linux 7.1 and 2.2% in Linux 7.2, a 35% drop (with the 30-day fix rate falling from 2.3% to 1.4%). It’s too early to make strong claims, and obviously many other factors can influence release-to-release numbers, so we cannot solely credit Sashiko for the entire drop, but the trend is optimistic.
Since Sashiko was rolled out, the percentage of merged commits in the Linux kernel that received a follow-up fix in 60 days has dropped by 35%.
A clean review carries real signal. If Sashiko's warnings were mostly noise, commits merged with warnings would need follow-up fixes no more often than commits that passed cleanly. In practice, across 21,500 tracked mainline commits, patches that received a clean Sashiko review required a follow-up fix within 60 days just 0.9% of the time — less than a third of the historical baseline. Patches merged despite a critical Sashiko warning needed a fix 7.6% of the time — an 8x higher risk (and 6.3x higher even after adjusting for patch size).
That gap is what makes Sashiko useful to maintainers: A clean pass instills real confidence, while a critical warning is a strong reason to take another look at the proposed patch.
This all tracks with what Linus Torvalds wrote in a mailing-list discussion a few weeks after Sashiko’s launch:
"As you say, Sashiko tends to be quite good. Even when it flags something unnecessarily and there's no actual problem, there's likely to be a reason for the question. And we've seen some truly stellar reports too. Things that are deep and subtle, and the AI is 100% correct. So anybody who thinks that all AI is slop is in denial about the current state." - Linus Torvalds (on lore.kernel.org)
| Sashiko at a glance | Since March 2026 |
|---|---|
| Patch reviews completed | 241,000 (~1200+ / day) |
| Opted-in kernel subsystem lists | 75+ |
| Mainline commits crediting Sashiko | 2,000+ |
| 2026 Linux kernel CVEs crediting Sashiko | 528 |
| 60-day post-merge fix rate | Down from 3.4% baseline to 2.2% (Linux 7.2) | First, benchmark-driven development beats intuition. While developing Sashiko, we tried many ideas that looked very reasonable on their face but didn’t end up working out. Other ideas were less obvious but worked surprisingly well. What was crucial: Early on, we built a benchmark out of nearly 1,000 real Linux kernel bugs and used it to evaluate every major Sashiko change. Every bug in this set was a real mistake that had passed human review by kernel experts, had been merged into mainline Linux, and later had to be fixed. On that benchmark, Sashiko with the new Gemini 4 Carbon model catches 75.8% of the bugs that human reviewers missed (using high thinking level).
Second, coding agents are not great at reviewing their own code. Models are trained to produce a working solution within a limited token budget. Asking these agents to review their own code might work well for isolated tasks, but for real, large codebases, creating a functional solution is often just 5-10% of the work. What’s really hard is to produce a solution that works all of the time, is well-integrated into the surrounding code, and doesn’t introduce subtle regressions. This is often substantially more complex and requires additional effort. Similar to human developers, agents benefit from external code review: Reviewers often spot issues that the initial author missed, even if they are not more experienced.
Third, open source and shared community ownership and development help to build trust. By being fully open and transparent from the beginning, Sashiko allowed anyone to run it the way they wanted: using different models (including open source and local models), customizing prompts, or even adopting Sashiko to other-than-Linux projects. This helped with community adoption and brought over 100 contributors to improve Sashiko, including some prominent kernel developers.
More and more engineers are putting local Sashiko instances into their coding-agent loops, so patches are checked against the community's review rules before a human maintainer ever sees them. We use the same workflow to build Sashiko itself ("Sashiko for Sashiko"), running it to review every change to its codebase and prompt pipeline both locally and through a Github integration.
Although Sashiko started in the Linux kernel, the need for an agentic trust layer applies across critical open-source software. Because the core review engine does not depend on C or on kernel-specific rules, the Linux kernel playbook (combining an open verification pipeline, community-owned domain guides, and a benchmark mined from historically known issues and fixes) can likely be applied to other foundational open-source projects such as GCC, LLVM, or Git.
"Now, I think the other side of AI - and this is where Sashiko comes in - is that it basically does end up being a tool that can then increase the trust in the patch. So AI giveth, and AI taketh away. But the basic issue shouldn't be AI per se, it should be that notion of 'trust'." - Linus Torvalds on LKML
You can check out Sashiko at sashiko.dev, or find the code on ** GitHub** to run it in your own development workflow.