DEV Community

Trieu Nguyen
Trieu Nguyen

Posted on

What 150+ Open-Source Projects Teach Us About AI Contribution Policies

An Empirical Analysis of Developer Governance in the Age of Autonomous Coding Agents


Executive Summary

The emergence of large language models (LLMs) and autonomous coding agents has created an unprecedented governance crisis across the open-source software (OSS) ecosystem. Over the past twelve months, volunteer maintainers have faced a deluge of plausible-looking but broken pull requests-a phenomenon widely referred to in maintainer circles as "AI slop."

In response, open-source projects across every tier-from the Linux kernel and Gentoo to Home Assistant, curl, and Scientific Python-have rushed to publish rules regulating generative AI contributions. Yet, nearly all of these policies are written as unstructured prose buried inside CONTRIBUTING.md, community wikis, or buried forum threads. As a result, contributors frequently miss them, autonomous AI agents cannot parse them, and maintainers remain trapped in manual, contentious triage loops.

To understand the emerging consensus and design standardized tooling for the developer ecosystem, we conducted an empirical survey examining AI contribution policies across 150+ open-source repositories and foundations, with an in-depth taxonomy of 25 foundational open-source projects spanning systems programming, runtimes, web frameworks, scientific computing, and foundations.

This article details the empirical findings of this dataset, reveals the critical failure modes of prose-based governance, and outlines the case for machine-readable, deterministic policy enforcement.


The Landscape: How Open-Source Governs AI Today

When analyzing the regulatory posture of open-source projects toward AI-assisted and AI-generated code, projects generally sort into three distinct tiers:

[Surveyed Projects Distribution]
├── Forbidden (16%)   ── Total ban on AI code and text (e.g., Gentoo, NetBSD, Debian)
├── Restricted (80%)  ── Conditional acceptance with human accountability (e.g., curl, Home Assistant, SciPy)
└── Permissive (4%)   ── Open experimentation without mandatory disclosure
Enter fullscreen mode Exit fullscreen mode

1. The Abolitionists: Outright Prohibition (16%)

Roughly 16% of surveyed projects enforce a total ban on generative AI contributions. These projects tend to operate in mission-critical infrastructure, low-level systems programming, and strictly audited distributions:

  • Gentoo Linux: In April 2024, the Gentoo Council enacted a blanket prohibition: "It is expressly forbidden to contribute to Gentoo any content that has been created with the assistance of Natural Language Processing artificial intelligence tools." The rationale centered on copyright ambiguity, potential GPL violations, and code quality degradation.
  • NetBSD: Classified AI-generated output under its "Tainted Code" doctrine: "Code generated by a large language model or similar technology... is presumed to be tainted code, and must not be committed without prior written approval by core."
  • Debian & OpenStreetMap: Enforce strict anti-bot and anti-synthetic data policies, citing unverifiable legal provenance and data pollution.

For these projects, the risk calculus is absolute: the cost of verifying legal provenance and debugging hallucinations far exceeds any velocity gain offered by external contributors.

2. The Realists: Conditional Acceptance & Human Accountability (80%)

The overwhelming majority (80%) of open-source projects have adopted a pragmatic, conditional posture. Rather than attempting an impossible ban on general developer tooling (such as IDE autocompletion or Copilot), these communities draw a strict line between human-supervised assistance and unsupervised autonomous generation:

  • Home Assistant (Open Home Foundation): Allows developers to use AI tools for drafting code, but expressly forbids autonomous bot pull requests and AI-generated responses to code reviews: "You must understand and be able to explain every change you submit in your own words. Do not use an AI tool to generate responses to maintainers."
  • curl: Maintains a zero-tolerance policy for unverified AI submissions. Following an inundation of synthetic reports that overwhelmed volunteer maintainers, curl permanently shut down its cash bug bounty program on January 31, 2026: "If an AI tool is used to find problems or analyze curl, the reporter MUST explicitly disclose that fact in the report... low-quality AI-generated vulnerability reports forced the closure of our cash bug bounty."
  • Scientific Python (SciPy / NumPy / SymPy - SPE 008): Mandates that contributors understand the mathematical and algorithmic implications of every line: "Submitting a patch or code snippet that a contributor does not understand or cannot support is unacceptable."

3. The Permissive Sandboxes (4%)

A tiny fraction of projects-typically experimental testbeds or projects explicitly evaluating AI coding capabilities-impose no restrictions on AI contributions, treating code quality purely on a post-hoc test passage basis.


Deep-Dive Analysis: The 10 Core Governance Attributes

Across the 25 deeply audited repositories, we analyzed the frequency of specific governance requirements. The data reveals an unmistakable community consensus on ten critical dimensions:

Governance Dimension Frequency in Dataset (n=25) Percentage Classification
Author Legal & Technical Responsibility 25 / 25 100.0% Universal Core
Granular Code Scope Regulation 25 / 25 100.0% Universal Core
Human Code Comprehension Attestation 25 / 25 100.0% Universal Core
Autonomous PR Bot Prohibition 25 / 25 100.0% Universal Core
Automated Review Comment Prohibition 25 / 25 100.0% Universal Core
Automated Issue Generation Prohibition 25 / 25 100.0% Universal Core
AI Co-Author / DCO Sign-off Prohibition 25 / 25 100.0% Universal Core
Human-to-Human Discussion Rule 24 / 25 96.0% Near-Universal Core
Mandatory / Expected Disclosure 22 / 25 88.0% Strong Majority
Git Commit Trailer Specification 6 / 25 24.0% Emerging Standard

Insight 1: The Principle of Personal Accountability (100%)

Every single surveyed policy establishes that a human author must take 100% legal and technical responsibility for the code. An AI model cannot sign a Developer Certificate of Origin (DCO), cannot enter into a Contributor License Agreement (CLA), and cannot be held liable for copyright infringement or software defects. Every policy explicitly rejects listing AI bots as git commit authors or co-authors (Co-authored-by:).

Insight 2: The Triage Asymmetry Problem (100%)

Generating 400 lines of syntactically valid code with an LLM takes five seconds. Reviewing that code-identifying subtle concurrency races, memory safety pitfalls, hallucinated APIs, or edge-case failures-takes an expert maintainer thirty to sixty minutes. Every project with a restricted policy has implemented strict rules against submitting unverified AI output to prevent volunteer burnout.

Insight 3: The Disclosure Split: PR Checklist vs. Git Trailers

While 88% of projects require or expect disclosure, they diverge significantly in implementation:

  • PR Description Checklists (64%): Projects like Home Assistant, Django, and SciPy ask contributors to check a box in the pull request template confirming whether AI was used and certifying human comprehension.
  • Git Commit Trailers (24%): High-discipline repositories (e.g., Linux kernel community proposals, Chromium-adjacent projects) prefer machine-parseable Git trailers conforming to RFC 5322, such as Assisted-by: Claude <claude@anthropic.com> or AI-Generated: false.
  • Informal Text (12%): Vague guidance asking contributors to "mention if AI was used" without specifying a location or format.

Why Natural-Language Policies Fail

Despite good intentions, natural-language policies written in markdown suffer from four fatal flaws:

  1. Invisibility to Contributors: Most first-time contributors do not read documentation before opening a pull request. A policy stated in CONTRIBUTING.md is discovered only after a maintainer leaves a reprimand.
  2. Opacity to AI Coding Agents: As developers adopt autonomous terminal agents (e.g., Claude Code, Cursor, Aider, Copilot CLI), these agents clone the repository and execute tasks without reading arbitrary human wikis. If a policy is not machine-readable, the agent cannot adjust its behavior.
  3. Subjective Enforcement Friction: When maintainers suspect a patch was generated by an LLM, questioning the contributor often triggers defensive arguments. Without automated verification, enforcement feels arbitrary and personalized.
  4. Leaked Workspace Artifacts: LLM agents routinely litter repositories with workspace metadata-such as .claude/, .cursor/, or prompt cache directories. Natural-language policies warn against this, but human reviewers frequently miss them in multi-file diffs.

The Path Forward: Deterministic, Machine-Actionable Policy

The open-source community solved code style with Linters and licensing compliance with SPDX identifiers. AI contribution policy requires the same evolution: from subjective prose to deterministic, machine-readable validation.

To address this gap, ai-policy-kit was developed around three core technical primitives:

┌────────────────────────────────────────────────────────┐
│                   ai-policy.yml                        │
│         (JSON Schema Draft-07 Specification)           │
└──────────────────────────┬─────────────────────────────┘
                           │
         ┌─────────────────┴─────────────────┐
         ▼                                   ▼
┌──────────────────┐               ┌──────────────────┐
│  Documentation   │               │   Verification   │
│  Generator       │               │   Engine & CI    │
│  - AI_POLICY.md  │               │  - lint-pr       │
│  - PR Template   │               │  - Action Gate   │
└──────────────────┘               └──────────────────┘
Enter fullscreen mode Exit fullscreen mode

1. Standardized Schema (ai-policy.yml)

Using JSON Schema Draft-07, repositories declare their stance in a single canonical file placed at .github/ai-policy.yml or the repository root:

version: "0.1"
level: "restricted"
categories:
  code: "restricted"
  docs: "permissive"
  tests: "restricted"
disclosure:
  required: true
  commit_trailer: "Assisted-by"
accountability:
  author_takes_responsibility: true
  author_understands_code: true
bots:
  automated_prs: "forbidden"
Enter fullscreen mode Exit fullscreen mode

2. Dual Generation: One Source of Truth

From this single file, maintainers automatically generate human-friendly documentation (AI_POLICY.md), agent-facing context blocks (AGENTS.md), and pull request templates with required verification checklists (.github/PULL_REQUEST_TEMPLATE.md).

3. Deterministic CI Validation (No "AI Detectors")

Probabilistic "AI detectors" (such as commercial LLM classifiers) are notoriously unreliable for source code, producing intolerable false-positive rates that punish non-native English speakers and concise programmers.

Instead, verification must remain strictly deterministic:

  • Does the PR contain the required Git commit trailer (Assisted-by:) or PR template checklist?
  • Did the author certify personal comprehension and responsibility?
  • Does the git diff leak agent configuration directories (.claude/, .cursor/, .aider/)?
  • Does an author have multiple unmerged automated PRs exceeding the repository rate limit?

When run as a zero-dependency GitHub Action, the policy gate executes in under two seconds, reporting clear, actionable feedback directly in pull request checks without exposing the repository to network dependencies or security risks.


Conclusion

The open-source ecosystem cannot thrive if maintainers spend their limited volunteer hours triaging low-effort synthetic code. At the same time, draconian bans that ignore the realities of modern developer tooling risk driving away genuine contributors.

The data from 150+ open-source repositories demonstrates that the community has already reached a consensus: AI assistance is permissible only when accompanied by explicit disclosure, human comprehension, and personal legal accountability.

By transitioning from ambiguous prose to standardized, machine-readable policies, open-source projects can automate enforcement, protect maintainer health, and build a transparent foundation for the future of software development.


The full dataset summary and machine-readable specification are publicly available under the MIT license at github.com/thanhtrieunguyen/ai-policy-kit.

Top comments (0)