17.25% of the Linux Kernel Is Now Written by Machines: The Numbers Behind the Milestone

For most of its 35-year history, the Linux kernel has been the closest thing software has to cathedral craftsmanship: millions of lines of C, reviewed line-by-line by a priesthood of maintainers, merged under a legal certification process that assumes a human wrote every function. That assumption is now formally dead. According to the Lunduke Journal’s tracking, 1,634 code submissions written by AI landed in the Linux kernel last week alone — another record — and so far in September, AI-generated code has made up 17.25% of all kernel patches.

One in six patches arriving at the substrate of the internet — the operating system kernel running Android, every major cloud, and most of the world’s servers — was written by a machine.

The number, and how we got here

The trajectory is more startling than the headline. The share of AI-written submissions has been climbing steadily all year, and the monthly count has grown by more than 2,700% since February. In early June the journal reported “over 2,000 AI-generated patches in the last 45 days”; by June 9 a single week hit 499, which was then a record described as 8% of all submissions. Three months later that weekly figure has more than tripled to 1,634, and the September share stands at 17.25% — better than double the June ratio.

Run the compounding forward and the uncomfortable question writes itself: does the kernel cross 25% by the holiday release, 50% sometime next year? The curve has not bent yet.

None of this happened by accident — or in secret

What makes the kernel’s situation different from AI slop flooding random GitHub repositories is that this influx is policy-sanctioned and tracked. After months of famously fierce internal debate, Linus Torvalds and the kernel maintainers published official AI coding guidelines in April 2026, and they are unusually strict:

• AI agents are banned from adding Signed-off-by tags. That tag carries legal weight under the Developer Certificate of Origin (DCO), and only a human can certify that they have the right to submit the code. Every AI-assisted patch still needs a human willing to put their name — and their legal exposure — on it.
• AI assistance must be declared with a formal Assisted-by: AGENT_NAME:MODEL_VERSION [TOOL] tag. This is why the numbers are measurable at all: the tracking is grounded in explicit, greppable attribution in the commit metadata, not guesswork.
• The human submitter owns everything. Botched AI code is the submitter’s bug, legally and reputationally. “You take full responsibility for your commits” is the deal.

The policy, documented at docs.kernel.org, made the kernel one of the first large projects to codify a “human in the loop, machine at the keyboard” workflow. The 17.25% figure is what that transparency buys: an honest census rather than a scandal.

Review becomes the bottleneck — and the job

Torvalds himself has been blunt about where this leads. He has rejected calls to make the kernel an “anti-AI project” — telling objectors they are free to fork — and argued the tools must be judged on technical merit like any other. But he has also been candid that AI-generated bug reports and patches are straining the review layer, at one point calling the kernel’s security mailing list “unmanageable” under a flood of AI-found, often duplicate, issues.

The economics are asymmetric and getting more so. Generating a plausible patch now costs essentially nothing; reviewing one still costs the scarcest resource in the ecosystem — a qualified maintainer’s attention. A widely shared analysis of the Linux 7.1 cycle framed it starkly: hundreds of first-time contributors, many shipping AI-drafted code, funneling into a maintainer corps that numbers in the dozens per subsystem. When AI code was 8% of patches, that was an inconvenience. At 17.25%, reviewer capacity is the production function of the kernel. Expect “code review engineer” to keep climbing the list of the most important jobs in open source — a shift Torvalds has all but endorsed in his own practice: in August he merged a patch he authored after an AI-assisted debugging marathon, and let the model write the commit message.

Why the kernel, and why so fast

Three forces converged. First, modern coding agents have gotten genuinely competent at the kernel’s bread and butter: driver fixes, cleanup patches, treewide mechanical refactors, and bug reports derived from static analysis. Trivial, high-volume work is exactly where LLMs shine and exactly what maintainers used to drown in.

Second, the April policy created a lawful on-ramp. Once attribution and liability were solved, corporate contributors — who legally could not touch the gray zone before — started shipping AI-assisted work at scale. The 2,700% growth since February begins almost exactly when the policy’s details were being finalized.

Third, the kernel’s own tooling normalized it. Torvalds publicly used AI assistance on his own patches, the documentation process codified it, and the culture followed the leadership. There is no longer any stigma to declaring Assisted-by — only to not declaring it.

What to watch

The honest caveats: “AI-generated” here means declared AI assistance, so the true share (undeclared use) is likely higher; and volume is not value — a large fraction of AI submissions are small fixes, not architectural work. The milestone measures throughput, not yet trust.

But the direction is unmistakable. The kernel is becoming a hybrid human-machine project in fact as well as policy, with humans migrating up the stack from writing code to certifying, reviewing, and taking responsibility for it. The DCO’s human signature was designed for a world where the person signing also typed the code. September’s 17.25% is the first hard evidence that this world is ending — and the kernel, as it has before, is writing the rulebook everyone else will copy.