Sashiko: Why AI Code Review Must Separate Finding Issues from Verifying Them
Google engineers Roman Gushchin and Eric Brewer detail the architecture of Sashiko, explaining that LLMs exhibit specific failure modes in code review—such as a tendency to save tokens, susceptibility to bias, and lack of persistent memory. To address these, Sashiko strictly separates the discovery of candidate defects from their verification, utilizing up to seven parallel single-focus expert sessions with deep per-issue checks. Production data over seven months shows that the Linux kernel's patch fix rate within 60 days dropped from 3.4% to 2.2% (in Linux version 7.2).
The development speed bottleneck in large open-source projects has never been code generation, but rather code review. The Linux kernel lands more than 85,000 changes annually, with maintainers manually reading hundreds of patches daily to check for memory leaks, deadlocks, race conditions, and security vulnerabilities. As AI coding agents multiply the speed of patch production, without mechanisms to build trust, more generated code simply piles up before the same small group of human maintainers.
In a blog post published in November 2026, Roman Gushchin and Eric Brewer of the Google AI & Infrastructure team detailed the architecture and production data of Sashiko, an open-source agentic code review system powered by Gemini. The system was donated to the Linux Foundation earlier this year and is named after the Japanese word sashiko (刺し子), a stitching technique used to reinforce worn fabric.
Sashiko’s architecture directly addresses three specific failure modes of LLMs as reviewers. First, LLMs tend to save tokens: trained to achieve goals within limited budgets, they often cut corners by dismissing concerns without thorough investigation or flagging false positives without proper due diligence. Second, LLMs are easily biased: current-generation models perform significantly better on single, relatively simple tasks than on multiple complex ones; once an LLM finds an obvious issue in code, it often refuses to dig deeper into other types of problems. Third, LLMs lack persistent memory—which is actually an advantage in code review, as the same patch can be reviewed repeatedly as if it were new.
The core design decision to counter these failure modes is to strictly separate the discovery of candidate defects from their verification, requiring each review stage to record what it ruled out. The specific process involves five steps: gathering context and planning, parallel expert sessions (outputting lists of concerns and dismissed candidates), triage, per-issue deep checks, and generating a review report.
Parallel expert sessions run up to seven ways simultaneously, with each focusing on a single class of issues: commit intent, implementation match, control flow, resource lifetimes, locking, security, and hardware. This single-focus approach prevents one type of bug from crowding out another. Each session averages about 100 git tool calls to search and read the repository, outputting two lists: concerns it believes are real, and candidate concerns it investigated and dismissed, along with the code evidence supporting those dismissals.
In the triage phase, a lead verifier audits both lists simultaneously. Clear-cut bugs already proven by the code pass straight through; dismissals proven by local checks are dropped. All other cases require further investigation. Crucially, this includes not only contested bugs where specialists disagreed, but also shaky self-dismissals: cases where a specialist did spot a real defect but dismissed it by assuming, without evidence, that some unseen caller or lock would prevent it.
In the per-issue deep checks phase, each difficult case is assigned its own independent verification agent running in parallel, rather than checking all difficult cases in one shared prompt. Each agent answers only one specific question, adhering to symmetrical rules: neither a bug claim nor a dismissal is accepted without concrete code evidence across all call sites. If a specialist talked itself out of a real bug based on a false assumption, this step catches it and promotes it back to a real finding.
Seven months of production data support the effectiveness of this architecture. Sashiko completes approximately 1,200 reviews daily across more than 100 kernel mailing lists, with maintainers from over 70 lists having opted in. It is cited in over 2,000 mainline kernel commits and in more than 500 official Linux kernel CVEs in 2026.
The most direct quantitative evidence is the change in fix rates: across the 18 kernel releases prior to Sashiko (Linux 6.2 through 6.19, covering 254,000 commits), an average of 3.4% of merged commits required follow-up fixes within 60 days. Since Sashiko went live, the rate dropped to 2.8% in Linux 7.1 and 2.2% in Linux 7.2—a relative decrease of about 35%. A more granular signal shows that among 21,500 tracked mainline commits, patches that passed Sashiko’s clean review required fixing within 60 days only 0.9% of the time—less than a third of the historical baseline. Conversely, patches merged despite critical Sashiko warnings required fixing 7.6% of the time, carrying 8 times the risk.
The authors acknowledge that the drop in fix rates alone cannot be solely attributed to Sashiko, as many other factors may influence numbers between versions. However, the 8x gap in fix rates between clean reviews and critical warnings indicates that Sashiko’s signals do have discriminative power.
At the methodological level, the authors emphasize benchmark-driven development over intuition. Early on, they built a benchmark comprising nearly 1,000 real Linux kernel defects, each being a genuine error that had passed human expert review, been merged into mainline, and later required fixing. After evaluating every major change using this benchmark, Sashiko paired with the Gemini 4 Carbon model at high thinking levels captured 75.8% of the defects missed by human reviewers. This is a first-party benchmark, built and run by the project team itself.
Another notable insight is that coding agents are not good at reviewing their own code. Models are trained to produce working solutions within limited token budgets, but for real large codebases, creating a functionally correct solution is often just 5-10% of the work. The real difficulty lies in producing a solution that works consistently, integrates well with surrounding code, and does not introduce subtle regressions. This mirrors human developers: reviewers often spot issues missed by initial authors, even if the reviewers are not more experienced.
Sashiko’s architectural pattern—separating discovery from verification, single-focus parallelism, and symmetrical evidence rules—does not depend on C language or kernel-specific rules. The authors argue that this Linux kernel playbook (an open verification pipeline, community-owned domain guides, and benchmarks mined from historically known issues and fixes) can be applied to other foundational open-source projects such as GCC, LLVM, or Git.
Linus Torvalds wrote in a mailing list discussion a few weeks after Sashiko’s launch: 'Sashiko tends to be quite good. Even when it flags something unnecessarily and there is no actual bug, there is likely a reason for the question; we have also seen truly stellar reports that are deep and subtle, with the AI being 100% correct.'