Updated: November 12, 2026
In one week in November 2026, two open-source projects pushed back hard against AI slop. A senior Linux kernel reviewer stepped back from most of his review work because AI-generated patches were burying his inbox. Days earlier, Asahi Linux, the project that runs Linux on Apple Silicon Macs, changed its license after its unreleased code was copied and run through AI tools to hide where it came from.
Let me be clear up front: I use AI coding tools every day. This isn't an anti-AI post. But these two stories show what happens when AI output gets dumped on volunteers with nobody owning it. And they carry lessons for every developer, agency and business that uses open source, which is all of us.
Quick answer: what is AI slop in open source? AI slop is low-effort, machine-generated content, such as patches, bug reports or documentation, submitted without real understanding, testing or ownership by the person sending it. It shifts the work onto maintainers, who must review it, often for free. AI-assisted work a human fully understands and owns is not slop.
What Is AI Slop in Open Source?
"Slop" started as a word for the flood of low-quality AI images and articles online. In open source, it means contributions that look plausible but weren't really thought through by the person who sent them.
It shows up in a few forms:
- Patches that compile but don't fit the codebase's design, or are far too large to review
- Bug reports that describe problems that don't exist
- Documentation that sounds confident but is wrong
- Follow-up replies where the contributor just pastes the maintainer's questions into a chatbot and pastes the answers back
The key difference isn't whether AI was involved. It's whether a human understands every line, tested it, can answer questions about it and will stick around to fix it. A carefully reviewed, AI-assisted bug fix is a contribution. A 40-patch series nobody can explain is a burden.
Story 1: A Linux Memory-Management Reviewer Steps Back
Lorenzo Stoakes is a memory-management expert at Arm who has contributed to the Linux kernel since 2014. Memory management is one of the most complex and sensitive parts of the kernel, and Stoakes has been one of its busiest reviewers.
On November 10, 2026, he posted a short, four-patch series that removes his name as a reviewer from several memory-management areas: core, reclaim, miscellaneous, transparent huge pages (THP) and the Rust bindings. He's keeping the areas he maintains, and he'll finish the work he's already doing.
His reason was written right into the patches. In plain terms, the volume of AI-generated patch series means he no longer has the time to review anything outside the areas he maintains. Phoronix's report and the patch series itself are worth reading in full.
The tone is calm, not angry. That's what makes it striking. In a thread on the kernel mailing list, he described how the slop grew from an occasional annoyance to a weekly one, then every few days. Today, he says, it's "pretty much half of what I see, if not more."

Background: a year of arguing about AI in kernel review
This didn't come out of nowhere. Throughout 2026, the memory-management community has debated how far to let AI into its workflow:
- March: Andrew Morton, the long-time memory-management maintainer, proposed requiring patch authors to respond to feedback from Sashiko, a new AI patch-review system. Stoakes and other sub-maintainers objected. They said that making the tool mandatory would add work for reviewers who were already overloaded.
- June: Stoakes reviewed a 40-patch, LLM-assisted series from an experienced developer and pushed back hard. His advice: don't send unfiltered AI code to the mailing list at all. Link to a repository instead.
- The rules: the kernel's own process guidance already warns contributors that tool-generated work gets extra scrutiny, and that maintainers may reject it without a detailed review.
Note the pattern. The problem isn't that a tool wrote some code. It's that someone else is expected to do the hard part, which is checking it.
Story 2: Asahi Linux Drops MIT for GPL After AI Code Laundering
Asahi Linux is the reason you can run Linux on an Apple Silicon Mac. For years, the project released most of its own code under the MIT license. MIT is about as permissive as it gets: anyone can reuse the code, even in a closed, paid product, as long as they keep the copyright notice.
In its progress report for Linux 7.3, published in early November 2026, Asahi announced that all of its repositories are moving to the GNU GPL, version 2 or later.
The reason is what many are calling AI code laundering. According to the report, bad actors took in-development code from contributors' personal forks before it was even released. Some of it was published without credit. Some was run through large language models to rewrite it and hide where it came from. Asahi describes this as an effort to replace the project and profit from Linux on Apple Silicon.

Asahi already had a strict rule here: its generative AI policy forbids AI-generated code contributions to the project. That rule protects the codebase but does nothing about what others do with it.
Why MIT couldn't stop it, and what GPL changes
MIT allows almost any reuse, so taking released Asahi code and building a closed product on it was legal, as long as the notice stayed. The GPL changes that. Anyone who distributes a modified version must release their source under the same license. A closed, paid fork becomes illegal, and public source makes copying easier to spot.
The GPL isn't a magic shield, though:
- It doesn't stop someone determined to ignore the law
- Code already released under MIT stays MIT. You can't take it back
- Taking unreleased code from someone's personal fork was arguably a violation anyway, under any license
There's precedent. WINE, the Windows compatibility layer, switched from MIT to the LGPL in 2002 for similar reasons: to discourage proprietary forks.
The criticism, fairly stated
Not everyone agrees. OpenBSD developer Bryan Steele criticized the move publicly. OpenBSD's own Apple Silicon support relies on Asahi's m1n1 bootloader, which was MIT-licensed. Critics have also asked whether every past contributor agreed to the license change, which normally requires their consent. Asahi hasn't explained that process in detail yet.
Both sides make fair points. But the fact that a volunteer project felt it had to change its license because of AI says a lot about where we are.
The Real Problem: AI Moves the Cost to Reviewers
Put the two stories side by side and the same pattern shows up. AI makes producing code nearly free. It does nothing to make understanding, reviewing or owning code cheaper. So the cost doesn't disappear. It moves to whoever has to check the work.

- Generating vs. reviewing. An AI agent can write a 2,000-line patch series in minutes. A careful reviewer might need days to read it, and memory-management code can corrupt data or crash machines if one line is wrong.
- Nobody home. Maintainers increasingly report contributors who can't answer basic questions about their own patches, or who disappear after the first round of feedback.
- Volunteer burnout. Much of open source runs on a small number of people doing most of the review. When one of them steps back, the whole project slows down.
- Provenance and licensing. When AI can rewrite code until its origin is hidden, licenses that depend on attribution lose their teeth. That's exactly what Asahi faced.
The result is a strange new tax. The easier it gets to generate code, the more scarce and valuable human review becomes.
Is AI-Assisted Code Always Bad? No.
It would be easy to read this as "AI ruins open source." That's not the full picture. The same week Stoakes stepped back, Linus Torvalds noted that much of the Linux 7.4-rc2 release was driven by AI-assisted fixes. Used well, AI is already finding and fixing real bugs.
The difference between helpful and harmful comes down to three things:
- Ownership: a human understands, tests and stands behind every line.
- Disclosure: the work is labeled, for example with an "Assisted-by" tag, so reviewers know what they're looking at.
- Scale: small, focused changes that a reviewer can actually check, not giant dumps.

AI coding tools also bring their own risks to your own projects, not just upstream ones. We've covered two this month: the Claude Code extension backdoor and the Claude Code settings.local.json leak, where secrets ended up on GitHub. If you're building AI features into your own app, that's a different topic, covered in our Laravel AI SDK guide.
A Responsible AI Coding Checklist for Developers and Agencies
Whether you're contributing upstream or shipping client work, these rules keep AI on the right side of the line:

- Understand every line before you submit it. If you can't explain it in review, don't send it.
- Read the project's AI policy first. Some projects ban AI-generated code entirely, as Asahi does. Others require disclosure.
- Disclose AI assistance in commit messages or PR descriptions when a project asks for it, and ideally even when it doesn't.
- Keep changes small. One logical change per patch. Split big work into reviewable pieces, and share large experiments as a link to a repo rather than a mailing-list flood.
- Test it yourself. Run the tests, add new ones and check edge cases. Don't rely on AI saying it works.
- Never launder licensed code. Running someone else's code through an LLM doesn't make it yours. Respect licenses and attribution.
- Review every agent diff before merging, even in your own repos. Tools like the workspaces in Laravel Herd 2 make this easier.
- Keep secrets out of prompts and commands. Our developer laptop security checklist covers the basics.
- Own the follow-up. Answer review questions yourself and fix what breaks.
- For client work, put it in writing. Agree on AI use, code ownership and licensing in the contract.
What This Means for Businesses Using Open Source
If your business runs on WordPress, Laravel, Linux or almost any modern web tech stack, it depends on maintainers like Stoakes, often unpaid. Maintainer burnout isn't just a community problem. It's a supply-chain risk: slower security fixes, abandoned packages and license changes you didn't plan for.
Three practical steps:
- Sponsor the projects you depend on. Even small amounts through GitHub Sponsors or Open Collective help.
- Watch for license changes in your key dependencies, especially moves to copyleft licenses that might affect how you distribute software.
- Hire people who use AI responsibly. Ask agencies and freelancers how they use AI and how they review its output.
For the bigger picture, see our website security for small business guide: a layer-by-layer plan, a 30-day checklist and typical costs.
AI Slop in Open Source FAQs
Conclusion: AI Is a Tool, and the Human Still Owns the Patch
One reviewer stepping back and one project changing its license might look like small events. Together, they show the real cost of AI slop: it moves the work from the people generating code to the people checking it, and those people are few and often unpaid.
The fix isn't to stop using AI. It's to use it like a professional: understand it, test it, disclose it and own it. That's how I approach AI in client projects too. If you want help building with AI without creating a mess for your team, take a look at how I work with clients or get in touch.
Sources
- Phoronix: Longtime Linux Developer Steps Down From Some Roles Due To Patch Flood Caused By AI
- MAINTAINERS: remove my reviewerships (patch series, linux-mm PR #6187)
- Tom's Hardware: Linux kernel reviewer steps down from memory management duties
- LWN: The role of LLMs in patch review
- Asahi Linux: Progress Report, Linux 7.3
- Asahi Linux: Generative AI Policy
- It's FOSS: Asahi Linux Drops MIT and Goes Full GPL
Comments (0)