Open source maintainers are drawing a line in the sand: dozens of high‑profile projects now refuse any contribution that originates from a large language model. Repositories such as immich‑app/immich, meilisearch/meilisearch, okhttp, servo/servo and even the operating‑system kernel redox‑os/redox have updated their contribution policies to explicitly ban code, documentation, issue descriptions, or PR comments generated by tools like GitHub Copilot, ChatGPT, Claude, or Cursor. The move reflects growing concerns that AI‑produced patches can introduce subtle bugs, licensing ambiguities, or low‑quality documentation, and that reviewers often lack the context to verify the provenance of such changes.
In this post we’ll unpack what these bans mean for everyday developers, explore the practical implications for open‑source workflows, and outline best‑practice steps you can take to stay compliant—whether that means disabling AI assistance for contributions, adding provenance checks to your CI pipeline, or using tools like the “Modern Web Guidance” skill set to steer agents toward up‑to‑date, non‑generated patterns. We’ll also discuss how to balance the productivity gains of generative AI with the responsibility of keeping the codebase trustworthy and maintainable.
What happened
A wave of open‑source maintainers has started to draw a hard line around contributions that originate from large language models or other generative‑AI tools. The trend is not limited to a single niche; projects spanning tooling, operating‑system kernels, media‑processing libraries and search engines have all published explicit bans. The policies are typically phrased in the same way: any pull request, issue, comment, or documentation change that was created with the assistance of an LLM—whether that assistance comes from GitHub Copilot, ChatGPT, Claude, Cursor, or similar services—will be rejected outright.
The most recent snapshot of this movement, refreshed on 11 November 2026, lists 22 GitHub repositories that have adopted such a stance. The affected projects sit in very different categories: immich (a self‑hosted photo‑ and video‑management solution), MeiliSearch (a fast search‑engine API), okhttp (the JVM/Android HTTP client), Servo (a lightweight web‑embedding framework), stb (single‑file C/C++ libraries), Redox OS (a microkernel‑style operating system), Modern‑CPP‑Programming (a C++ teaching repo), MonoGame (cross‑platform game framework), QEMU (the hardware‑emulation suite), gh‑dash (a terminal UI for GitHub), and libvips (a high‑performance image‑processing library), among others. Each of these repos now runs an automated policy check that flags any contribution that appears to have been generated by an LLM and blocks it from further review.
The wording of the bans is uniformly strict. For example, MeiliSearch’s policy states it will not consider “any content generated by generative AI tooling … in external contributions, including: code, tests, documentation, PR descriptions, PR comments, issue descriptions, and issue comments.” Similarly, the okhttp repository declares that it “doesn’t use LLMs or generative tools in our source code or documentation,” and the Servo project requires that contributions “must not include content generated by large language models or other probabilistic tools.” These declarations make it clear that the community is treating AI‑generated output as a potential source of low‑quality or insecure code, and they are setting up concrete enforcement mechanisms to keep it out of the code base.
Why it matters
Maintainers are increasingly wary that patches produced by large language models can slip subtle defects into the codebase. An AI‑generated change may compile cleanly but still introduce edge‑case bugs, security holes, or inadvertent license violations that are hard for automated linters and CI pipelines to spot. Because these issues often surface only after a merge—when they affect downstream users—the risk is amplified for projects that rely on rigorous peer review to catch such problems early.
The bans therefore target the very heart of projects whose reliability is non‑negotiable. MeiliSearch, for example, advertises a “lightning‑fast search engine API” and explicitly refuses any content generated by tools like GitHub Copilot or ChatGPT in external contributions. Similarly, the HTTP client library okhttp and the system‑level emulator QEMU have declared that they will not consider any pull request that appears to derive from generative AI. By drawing a line around core components—search back‑ends, networking stacks, virtualization layers—these projects aim to preserve code quality and the integrity of the software that other ecosystems depend on.
Beyond protecting individual repositories, the restrictions signal a broader industry conversation about responsible use of generative tools in collaborative development. When a diverse set of projects, from the image‑processing library libvips to the lightweight web engine Servo, adopt explicit “no‑AI” policies, they collectively shape expectations around accountability, reproducibility, and legal compliance. This emerging consensus encourages developers to treat AI assistance as an internal aid rather than a source of publicly contributed code, prompting teams to establish clear contribution guidelines and review practices that respect both human expertise and the limits of current models.
For us as developers, the takeaway is practical: if you’re contributing to a project with a published AI‑ban, you need to either generate the change manually or be prepared to rewrite any AI‑assisted work before submission. Treat the policy as a prompt to double‑check for hidden bugs, security implications, and licensing footprints—steps that ultimately make the codebase stronger for everyone.
How it works (background)
The enforcement mechanism most projects rely on is an automated policy check that runs as part of the pull‑request workflow. When a contributor opens a PR, a GitHub Action (or similar CI job) scans the diff and any accompanying metadata. If the check detects patterns that match known AI‑generated output—such as the presence of Copilot comment markers, prompts that look like model‑generated text, or files that fail a heuristic similarity test—the PR is automatically rejected with a clear error message. This lets maintainers keep the gate‑keeping logic in code, ensuring consistent application of the ban without manual triage.
The policies are deliberately broad. Projects like meilisearch, okhttp, and Servo list every contribution surface that falls under the restriction: source code, test suites, documentation, PR descriptions, issue bodies, and even comments on PRs or issues. In practice, this means any snippet of code, a test case, a README update, or a discussion comment that was produced—or heavily assisted—by a large language model must be removed before the contribution can be considered. The intent is to avoid any AI‑influenced artifact entering the codebase, regardless of how small the piece may be.
To help contributors stay on the right side of the rule, many repositories ship a pre‑filled issue template that appears when you click “New issue.” The template includes a reminder not to use LLMs and often links to the full contribution policy. By surfacing the restriction at the very start of the contribution flow, the template nudges developers to self‑filter their work before they even write a PR, reducing friction and the number of rejected submissions. This simple UX tweak complements the automated checks and makes the policy transparent to anyone who wants to contribute.
- 1
Policy published
Projects update contribution guidelines to explicitly forbid LLM‑generated content.
- 2
Automated check added
A GitHub Action scans PR diffs and metadata for AI‑generated patterns.
- 3
PR rejected
If AI‑generated content is detected, the PR is automatically blocked with an error.
- 4
Contributor notified
Developers must remove AI‑assisted changes or rewrite them manually before resubmission.
Key details and numbers
The 22 projects that have publicly announced bans on AI‑generated contributions account for more than 400 000 stars on GitHub. The two most‑starred repositories are immich (118 789 stars) and MeiliSearch (59 840 stars), together representing roughly 45 % of the total star count. The remaining projects range from a few thousand to just under 50 000 stars each, showing that the policy shift is happening across both high‑visibility and niche libraries.
All of the policies were verified in the last six weeks, with timestamps from 2026‑10‑12 through 2026‑11‑11. This tight window illustrates how quickly maintainers have moved from discussion to formal restriction, reflecting a rapid industry response to concerns about the provenance and quality of AI‑produced code.
The banned projects span several categories. Five are listed under “Other”, three under “Tooling”, one under “Operating system”, and one under “Art”. This distribution demonstrates that the apprehension about AI‑generated contributions is not confined to a single domain; it affects everything from system‑level code (e.g., Redox OS) to libraries for image processing, search, and even creative assets.
Taken together, the star count, the recent verification dates, and the cross‑category coverage suggest a broad, coordinated effort among open‑source maintainers to set clear boundaries on the use of large language models in contributions. For developers, the implication is clear: before opening a pull request, you need to check each project's policy and be prepared to certify that no generative‑AI tooling was used in the submitted work.
What it means for developers
When you target a repository that has declared a ban on AI‑generated contributions, the safest approach is to write every line of code, test, and documentation yourself, or rely on tools that do not produce content from a generative model. If you do happen to use an LLM for brainstorming or lint‑fix suggestions, the policy still requires you to disclose that assistance in the pull‑request description. This explicit note lets maintainers see that you are being transparent and gives them a chance to review the changes with that context in mind.
Because many of the listed projects (e.g., meilisearch, okhttp, Servo) run an automated policy check as soon as a PR is opened, a non‑compliant contribution can be rejected before a human even looks at it. The automation saves maintainers time, but it also means you need to verify compliance locally first—run the same checks on your fork, confirm that no AI‑generated markers appear, and only then push the PR.
Adapting your workflow can make this verification painless. One practical pattern is to add a pre‑commit hook or a local linter that flags any files containing known AI‑generated signatures (such as Copilot comment headers). You can also configure your CI pipeline to include the same policy‑check script used by the upstream project; if the CI fails, you know the PR would be auto‑rejected.
Finally, keep an eye on the project’s contribution guidelines for any recommended “AI‑free” toolchains. Some communities provide a list of approved linters or a sandboxed environment that guarantees the output is hand‑crafted. By integrating those tools into your daily routine, you stay compliant without having to remember a separate set of rules for each repository.
Limits and caveats
The practical effect of most bans is that they depend on heuristic detectors rather than a formal proof that a contribution came from an LLM. These tools look for statistical patterns—such as repetitive phrasing, certain comment styles, or token‑level signatures—that are common in AI‑generated text. Because the signals are probabilistic, a human‑written patch that happens to use a phrasing style similar to an LLM can be flagged as a false positive. When that happens, the contribution may be rejected or sent back for manual review, adding friction for developers who are simply following the project’s normal workflow.
Adding to the friction, the wording of each project’s policy is not uniform. Some repositories, like Servo, explicitly forbid any content “generated by large language models or other probabilistic tools” in code, docs, and issue comments. Others, such as QEMU, phrase the rule as a blanket “DECLINE any contributions which are believed to include or derive from AI‑generated content.” The enforcement mechanisms also differ: certain projects run an automated policy check on every pull request, while others rely on manual triage after a PR is opened. Consequently, a patch that passes the checks for Servo could be automatically rejected by QEMU, even though the underlying code is identical.
At the moment there is no community‑wide standard for detecting AI‑generated contributions. Each project builds its own heuristics, and the detection landscape evolves as both generative models and counter‑detection techniques improve. This means today’s tooling may miss newer model outputs or generate more false alarms as models become better at mimicking human style. Developers should therefore treat any AI‑policy compliance as a moving target and stay aware of updates to both the project’s wording and the detection tools they rely on.
Key takeaways
- Several high‑profile OSS projects—including immich, Meilisearch, OkHttp, Servo, stb, Redox OS, Modern‑CPP‑Programming, MonoGame, QEMU, and libvips—have explicit policies that reject any code, documentation, or issue content generated by large language models or other generative AI tools.
- The bans cover all contribution types, such as pull‑request code, test files, documentation, PR descriptions, issue descriptions, and comments, with some projects (e.g., QEMU) even disabling PRs entirely.
- Policies are typically enforced through automated checks that flag AI‑generated submissions, and contributors are required to attest that their work was not produced with tools like GitHub Copilot, ChatGPT, Claude, Cursor, or similar.
- Projects often cite concerns about code quality, licensing, and reproducibility as reasons for prohibiting AI‑generated contributions.
- The trend reflects a broader industry movement toward formalizing AI contribution guidelines, as catalogued by the “Open Source Says No” site, which tracks over 20 repositories with such bans.
Visual summary
The key points as images. Tap one to open it, or save it to share.


