Linux creator and longtime lead maintainer Linus Torvalds has utilized Anthropic’s AI-powered programming assistant, Claude Code, to resolve a notoriously stubborn performance bottleneck within the Linux kernel. The issue, which had frustrated kernel memory-management developers for more than two years, centered on page-cache reference counting. By turning to automated assistance, Torvalds managed to submit a 10-patch series that yielded a remarkable 23-fold throughput improvement in a synthetic benchmark executed on his personal AMD Ryzen Threadripper system.
The breakthrough marks a fascinating turn in Torvalds’ public relationship with artificial intelligence tools. Known for his candid and often critical perspective on developer productivity claims—particularly regarding assertions that AI writes the vast majority of modern codebases—Torvalds nonetheless directed Claude Code to draft the implementation, write corresponding tests, prepare initial documentation, and thoroughly review the generated source code. This collaborative effort culminated in an experimental branch that ultimately reshaped one of the most critical foundational data paths in modern operating systems.
The Genesis of the Page Cache Contention Problem
The performance degradation that prompted Torvalds’ intervention stems from an architectural feature deep within the Linux kernel: the page cache. Specifically, the bottleneck involves folio reference-count operations residing within the standard buffered-read execution path. When multiple CPU cores attempt to read from the page cache simultaneously, atomic reference-count updates on the underlying memory folios cause severe cross-core synchronization overhead.
The scale of the problem was astonishing. According to diagnostic data highlighted by hardware analysis outlets, folio reference-count contention accounted for an overwhelming 99.92% of cross-core load HITMs (Hit In Modified cache lines) during standard eight-thread testing on Torvalds’ Intel Core i7-8565U development laptop. This meant that the processors spent an enormous proportion of their compute cycles simply coordinating access to memory states rather than executing useful instructions.
The issue was initially brought to the broader development community’s attention in 2024 by Matthew Wilcox, a distinguished Oracle engineer and veteran Linux kernel memory-management developer. Wilcox flagged the bottleneck after it surfaced organically within a high-performance enterprise customer workload, triggering a multi-year effort across the engineering community to find an effective mitigation.
A Timeline of Frustration and Failed Approaches
For nearly two years, kernel developers struggled to devise a safe workaround. The inherent complexity of the Linux memory management subsystem makes altering reference counting extraordinarily hazardous; mistakes can lead to catastrophic memory corruption, use-after-free vulnerabilities, or system panics.
Torvalds himself admitted to spending roughly 18 months running a flawed, locally patched version of his own attempted fix for the reference-counting bottleneck. Concurrently, other core developers attempted various alternative approaches, all of which encountered architectural roadblocks, race conditions, or performance trade-offs that prevented them from being merged into the mainline kernel.
The situation shifted dramatically when eagle-eyed kernel observers, including Phoronix journalist Michael Larabel, spotted an unusual experimental branch named noref-filemap-read-with-llm sitting inside Torvalds’ publicly accessible git tree. The presence of this branch signaled that Torvalds was testing AI-generated code directly within his maintenance workflow.
Working under Torvalds’ direct supervision, Claude Code produced an initial eight-patch series designed to bypass folio reference-count operations on common read paths. Following initial testing and community review, this evolved into a refined 10-patch series designated as rcu-free-v3.
Technical Breakdown of the Claude-Assisted Patches
Earlier experimental approaches to solving the page-cache contention problem typically attempted to copy file data to user space without holding a folio reference, subsequently validating the folio’s integrity afterward. However, this optimistic strategy left open dangerous race conditions involving page reclamation, truncation, and memory replacement, making it unacceptable for mainline inclusion.
The Claude-assisted rcu-free-v3 series solved these race conditions through a more sophisticated design. Instead of bypassing checks entirely, the patches introduce a novel PG_rcu_free flag alongside Read-Copy Update (RCU) delayed reclamation. This mechanism protects the memory folio throughout the user-space copy operation, provided that the copy completes without triggering a page fault.
By eliminating the traditional folio reference-count manipulations from the primary buffered-read path, the patches fundamentally alter how multi-threaded workloads interact with system memory.
Benchmark Results: Laptop versus Threadripper
The performance gains demonstrated by the patches were dramatic, though their real-world impact varies significantly depending on hardware architecture and workload characteristics.
On Torvalds’ modest Core i7-8565U laptop, the initial eight-patch implementation nearly tripled throughput in controlled tests, pushing eight-thread read performance from approximately 10 million reads per second to upwards of 33 million reads per second. Concurrently, the kernel execution cycles required per read plummeted from roughly 2,950 down to 725.
When the more refined patches were applied to Torvalds’ high-end 64-thread AMD Ryzen Threadripper workstation under severe multi-core contention, the performance metrics scaled exponentially. Synthetic benchmark throughput surged from 13.3 million reads per second to a staggering 304 million reads per second—representing the reported 23-fold improvement. Kernel cycles per read dropped precipitously from nearly 20,000 down to 735.
Despite these impressive synthetic numbers, Torvalds cautioned that standard real-world workloads would experience considerably more modest gains, as storage I/O latencies, file system overhead, and application-level processing typically dwarf the micro-optimizations achieved in the page-cache layer. Furthermore, the optimizations introduced minor regressions in specific edge cases; for instance, reads into unmapped user pages occasionally triggered supplementary page faults, marginally increasing cycle counts for single-threaded operations.
Community Reception, Race Conditions, and Code Handover
As is standard within the rigorous Linux kernel development community, the submission of the patch series immediately sparked intense peer review and technical debate among subsystem maintainers.
Matthew Wilcox challenged the implementation of the new PG_rcu_free flag, arguing instead for the utilization of an explicit page type and proposing that inactive-list folios should be reclaimed following an RCU grace period. Torvalds pushed back against these suggestions, maintaining that the flag must be set while a folio remains actively eligible for user-space mapping, and noting that inactive-list reclamation would fail to properly cover file truncation and hole-punch operations.
To address hardware architecture concerns, Kiryl Shutsemau—a prominent Linux kernel developer who had previously worked on the very same memory bottleneck—suggested restricting the usage of the new flag exclusively to 64-bit systems. This architectural compromise garnered support from David Hildenbrand, an Arm engineer and established Linux memory-management maintainer.
During the peer review process, Shutsemau also uncovered a subtle race condition within the newly introduced filemap_read_rcu_batch() function. Specifically, if a folio replacement occurred concurrently with an extension of the file size (i_size), the system risked exposing stale or unwritten data to user space. Torvalds promptly recommended shifting the file-size read operation earlier in the execution flow and consolidating the folio validation checks, adjustments that Shutsemau successfully integrated into the updated patch set.
Following these architectural refinements and the identification of ongoing reclamation complexities, Torvalds officially transitioned the active development and fine-tuning of the patch series to Shutsemau, ensuring that expert human oversight guides the code toward eventual mainline integration.
Broader Implications for AI in Systems Engineering
The intervention of Anthropic’s Claude Code in resolving a two-year Linux kernel bottleneck carries significant symbolic and practical weight for the software engineering industry. For years, skeptics within systems programming argued that artificial intelligence tools were primarily suited for generating boilerplate code, web applications, or high-level scripting, remaining fundamentally ill-equipped for low-level, performance-critical, and highly concurrent systems software like the Linux kernel.
Torvalds’ successful deployment of an AI assistant to dissect and rewrite core memory-management logic challenges this narrative. While the AI did not operate autonomously—requiring precise architectural direction, rigorous human benchmarking, and extensive peer review by veteran kernel maintainers—it successfully synthesized a complex algorithmic solution that eluded human developers for nearly 24 months.
Ultimately, the episode illustrates a maturing paradigm in systems engineering: artificial intelligence functioning not as a replacement for human architects, but as an advanced collaborative engine capable of navigating combinatorial complexity, drafting intricate memory-management logic, and accelerating the resolution of deep-seated technical debt in mission-critical infrastructure.
