Opinion

Open Source Projects Draw a Line on AI Code

More open source projects are rejecting or restricting AI-generated contributions. The real dispute is not whether AI can write code, but who remains accountable for the code it produces.

Font size

Behind 43 Points: The Community Draws a Line

Open source projects are starting to take public positions on whether they should accept AI-generated contributions.

The aggregation site I found is osssaysno.com. It collects public statements from open source projects about AI-generated contributions, along with maintainers' views on code provenance, review practices, and maintenance responsibility.

The issue reached the Hacker News front page. The discussion, titled “OSS projects banning AI-generated contributions,” links to osssaysno.com.

At the time the material was recorded, the Hacker News discussion had 43 points and 50 comments. Entry points:

Forty-three points is not a large score, but 50 comments is a concentrated discussion. On HN, that means the topic did not attract broad interest, but the disagreement was substantial.

One camp supports restrictions. Its members argue that maintainers have no obligation to absorb the review costs associated with anonymous tools. Another camp argues that a blanket ban would obstruct individual developers who use AI and incorrectly equates “uses AI” with “untrustworthy code.”

On the surface, this is a debate over whether AI should be used to write code. More precisely, the community is drawing a boundary of responsibility: generated code may enter a project, but generators, maintainers, and contributors cannot use tools to conceal who is accountable.

The Rejected Patch Is Not AI, but One Nobody Owns

Maintainers are less concerned with whether an LLM can produce syntactically correct functions than with whether they can understand and maintain what it produces.

The central question is: Can maintainers understand AI-generated code and continue maintaining it, rather than whether the code can be generated in the first place.

A patch passing CI does not mean it belongs in a codebase intended for long-term maintenance. Maintainers still have to answer several harder questions:

  • Where did this code come from?
  • Does it copy code protected by copyright in the training data?
  • Does the contributor understand the implementation and its edge cases?
  • Who is responsible for explaining and fixing a security issue?
  • Who takes ownership of the AI-generated code after the project stops being maintained?

This is what distinguishes AI code from ordinary low-quality contributions. Low-quality code usually still has a clear author who can explain the design intent and acknowledge mistakes.

AI-generated code often breaks the chain of responsibility. The contributor clicks the submit button but may struggle to demonstrate line by line that they understand the generated result. Once the code enters a critical path, however, the community bears the future maintenance cost.

Licensing is even more difficult. Training data is generally not public, and model providers usually offer their own terms of use rather than itemized guarantees covering potential duplication in generated output.

This does not automatically prove that generated code infringes copyright. It does, however, shift the burden of proof onto maintainers: the project must trust that the code has a clean provenance before it can merge it confidently.

Those opposed to AI contributions are therefore not merely saying “do not use AI.” They are saying, “Do not disguise an unexplainable, unaccountable patch as an ordinary contribution.”

“Banning” Is the Surface; the Contribution Process Is the Core

“Ban all AI-generated contributions” is easy to circulate but may be difficult to enforce.

AI is already embedded in editors, issue templates, code completion, and automated Agents. Even when maintainers do not explicitly ask contributors to “use AI,” they may struggle to determine the provenance of code from the final diff alone.

A more enforceable approach is to make the contribution process traceable.

For example, a project could require contributors to state in a PR:

  1. Whether AI was used to generate or modify the code.
  2. Which tools and models were used.
  3. Which parts were generated by AI.
  4. Whether the contributor independently verified the implementation.
  5. Whether they checked licensing, secret exposure, and dependency supply-chain risks.

This should not remain a general appeal. It needs to become part of templates, CI checks, and review rules. A GitHub pull_request_template or a checklist in a contribution guide can leave an auditable record.

Below is a simplified PR template. It is not an official configuration for any particular project; it demonstrates one practical implementation:

name: AI-assisted contribution
description: Declare how AI tools were used in this pull request
body:
  - type: checkboxes
    id: ai-disclosure
    attributes:
      label: AI usage disclosure
      options:
        - label: This contribution was generated or modified with AI assistance
          required: true
        - label: I reviewed and understood every changed line
          required: true
        - label: I checked dependency licenses and accidental secret exposure
          required: true
  - type: textarea
    id: ai-details
    attributes:
      label: Tools, models, and affected files
    validations:
      required: true

Policies can also be tiered rather than treating every contribution the same way:

  • Documentation, test fixtures, and low-risk utility scripts: permit AI use with mandatory disclosure.
  • Core libraries, security modules, and permission-related code: require detailed explanations by section and an additional reviewer.
  • Dependency upgrades, license changes, secrets, and infrastructure code: prohibit direct submission of automatically generated code.

The key issue is not whether the label says “AI” or “human.” It is whether maintainers can understand and validate the contribution and identify a responsible party when something goes wrong.

Corporate Open Source Projects Will Tighten Rules Earlier

OSS projects maintained by companies are likely to enforce these rules sooner.

The reason is that they face more risks internally: code will enter a public repository, contributors may come from outside the organization, security teams need to assess the attack surface, legal teams need to verify licensing, and audit teams need to preserve decision records.

An undisclosed AI contribution can create four categories of cost:

  • Security cost: Generated code may introduce insecure defaults, broken access controls, or hidden dependencies.
  • Licensing cost: It may be difficult to verify the provenance of code and third-party fragments.
  • Audit cost: It may be unclear who wrote each section and which parts received human verification.
  • Brand cost: Once a project is overwhelmed by low-quality AI PRs, the act of responding to them becomes a public event.

This differs from internal corporate development. Internal projects at least have employee identities, ticketing systems, and code review records. A public repository receives contributions from strangers, and anyone can submit a patch that appears complete.

Companies are more likely to adopt an “assistants allowed, disclosure required” policy. The logic is practical: overly strict rules will drive legitimate users of AI assistance to bypass them, while no rules at all will overwhelm maintainers with low-quality PRs.

Companies will also keep their most sensitive components in closed-source repositories. Public projects tend to focus on licensing, brand reputation, and external attack surfaces rather than publicizing their AI usage rates.

Editorial Perspective

The open source community is unlikely to converge on a universal ban. Projects face different risks and have different numbers of maintainers. A more realistic path is a tiered system: permit AI use while requiring disclosure of tools, identifying generated sections, and retaining explicit human responsibility for verification. Core code would face additional review requirements.

This round differs from earlier debates over whether AI programming tools improve productivity. Those discussions focused on whether developers should use Copilot, Claude Code, or Cursor. The current debate concerns whether generated artifacts belong in public codebases and who is accountable when something goes wrong. Tool productivity benefits the individual developer; maintenance responsibility costs the community.

My assessment is that the projects that prevail will not be those with the strictest rules, but those with the clearest ones. More projects will adopt approaches resembling formal verification or SBOMs: content that cannot be traced and verified should not enter high-trust paths.

One question remains unanswered for now: the licensing provenance of AI-generated code is still difficult to verify. Even full disclosure of the model and prompt does not automatically prove that the code contains no copied training material. Disclosure establishes the chain of responsibility; it does not resolve the chain of copyright. The next boundary the open source community draws may not separate “AI” from “human,” but verifiable contributions from unverifiable patches.

Source: https://osssaysno.com