AI transparency for Open Source projects

Say which AI wrote it

AI tools now write a growing part of the code that reaches Open Source projects. Whether to accept it is each project's choice. Where it is accepted, it should be done openly and with trust. What a project needs first is to know it: one line at the end of each commit, and a person who answers for the change.

This page describes one practice: that of a project which accepts AI-assisted contributions and asks that they be declared. Other projects choose otherwise, and their rules are compared on another page.

Why it matters

  • Reviewers read differently. Generated code fails in its own ways: plausible but wrong, wider than the task, confident about things nobody checked. A reviewer who knows which model wrote a change knows where to look.
  • The cost has moved to the reviewer. Writing a change has become cheap; reading one has not. A maintainer who is free to ignore what they do not want to read can live with any number of pull requests. Many are not: they feel they owe every contributor an answer, and their time is what a project runs on. A declared change tells them at once what kind of reading it needs.
  • Responsibility stays with a person. A model cannot answer a review, fix a regression in six months, or be asked why. Saying that an AI wrote the change, and that you read, understood and tested it, keeps a human answerable.
  • The history stays honest. A repository is also a record of who did what. When a model is named, the project can later find what a given model or version wrote, for example after a class of defects is discovered.
  • Nobody has to hide. When declaring AI use is the normal thing, a newcomer who could not have written the change alone can say so, and ask for the review they need. Silence helps no one, and shame is what produces silence.

For those who use AI, and for those who do not

This practice is meant to help everybody. A project can use AI tools every day and still be a good place for people who do not want to.

  • No one has to use AI. People refuse these tools for many reasons, and they do not owe an explanation. They deserve support, not only tolerance: the documentation, the review and the help of the project stay there for someone working without an AI tool.
  • No one is asked to. A maintainer who uses AI does not ask a contributor to do the same, and a contribution written by hand is reviewed like any other.
  • No one is turned away for using it. Declaring AI use never counts against a contribution. OCaml calls this judging on merit.

Declaring is what makes both possible. When AI use is said, those who avoid it can see where it is, and those who use it have nothing to hide. The Software Freedom Conservancy puts these two points first in its recommendations on LLM-backed generative AI: support those who reject these systems, and let every contributor decide for themselves.

A shared vocabulary

"AI-assisted", "AI-generated", "vibe-coded": people use these words loosely, and each project that writes rules picks its own. A vocabulary now exists outside any project: AI Content Disclosure for HTML, the final report of a W3C community group, published on 9 October 2026. It was written for web pages and it is a community report, not a W3C standard. Its three values apply to a contribution as they are, and this page uses them throughout:

ValueMeaningFor a contribution
human-onlyA positive assertion that no AI was involved.Something a person states. A commit without a trailer does not state it.
ai-assistedAI was involved, and a human reviewed the result before publication.The trailer, and a person who has read, understood and tested the change.
ai-autonomousAI was involved, and the result was published without human review.What an agent submits on its own.

Three things in it are worth taking.

  • Two questions decide, in this order. Was AI involved? Did a human review the result before it was published? These are the two boxes of the pull request template.
  • The amount does not decide. In the words of the report, "The amount of AI-authored text and the extent of human editing do not determine the value." Light editing and a full draft are both ai-assisted once a person has reviewed them. The line that matters is the review, which is also the line nearly every project draws.
  • No declaration means "unknown". It is distinct from human-only. This is what "no AI declared" means on this site.

The Co-Authored-By trailer

A commit that was not written by a human ends with a trailer naming the model and its version:

fix: [website] Forms no longer drawn inside a grey box

The extra classes went to the form element itself, which gave the
whole form the look of an input.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

It is an existing git convention, the one already used for pair programming. It travels with the commit through forks and mirrors, it is shown by GitHub and GitLab, and any script can read it. Nothing has to be installed.

  • Name the model and the version, not only the tool: "Claude Opus 5.5" rather than "Claude" or "an AI assistant". The version is what makes the history useful later. The identifier that the provider's API uses, when the tool knows it, is less ambiguous still than the name shown to people.
  • One trailer per commit, on every commit the model wrote, not once per pull request.
  • Keep it when squashing. A squash merge that drops the trailers erases the declaration.
  • Leave it out of commits you wrote yourself. The trailer is a fact about a commit, not a label on a person.

Several tools add the trailer by themselves; others do when the project asks them to, which is what AGENTS.md is for.

Co-Authored-By is not the only name in use: some projects ask for Assisted-by or Generated-by, and some do not allow a model to be named at all (the trailers of other projects). The name matters less than three things, which hold whatever a project chooses: the line is in the commit, a script can read it, and it names the model and its version.

Without the trailer, these pages say little

Everything this site shows is read from what contributors declare. A commit without a trailer is counted as no AI declared, and nothing in a repository can tell a commit written by hand from a generated one whose trailer is missing.

So the figures of a project are as reliable as its habit of declaring. In a project that asks for the trailer, and where agents are told to add it, "no AI declared" comes close to "written by a person". In a project that asks for nothing, a low share of AI commits may only mean that nobody says it. In both cases the figures are a lower bound.

We are not alone in reading silence this way. In the vocabulary of the W3C community group, content without a declaration is "unknown", which is distinct from human-only.

This is the reason to adopt the practice below: it makes the declaration the default, instead of leaving it to each contributor's memory.

Four files that make it a habit

This is what Vulnerability-Lookup did. Each file speaks to a different reader.

1. CONTRIBUTING.md, for people

The reference. It states the rules, and the two files below repeat them. Here is a section to copy, with the seven commitments of the charter under their own names. Set the date, and change the words to your project's own:

CONTRIBUTING.md

## Use of AI and LLM tools

This project adopts the [AI transparency charter][charter] 1.3. These
rules apply to contributions made from YYYY-MM-DD.

AI-assisted contributions are accepted. Contributions written without any
AI tool are accepted in the same way: nobody has to use one, and nobody
has to explain why they do not. In both cases a pull request is the
responsibility of the person who submits it.

- **Say so.** Mention in the pull request description when a significant
  part of the change was generated with an AI tool, and end each commit
  that was not written by a human with a `Co-Authored-By` trailer naming
  the model and its version, for example:

  ```
  Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
  ```
- **A human answers for it.** Every change in a pull request must be read,
  understood and tested by its author before it is opened, whoever or
  whatever wrote it. Say it in the pull request: keep the template's
  sections, and tick its last box yourself.
- **Be able to explain it.** Reviewers may ask you to explain any part of
  your change. Answer review comments yourself, not with pasted LLM
  output.
- **A human submits.** Pull requests opened by an agent on its own,
  without a human author who reviewed them, will be closed.
- **Report only what was reproduced.** The same applies to issues: report
  a problem that you have observed yourself, and describe what you
  observed.
- **No shame, no ranking.** Declaring the use of an AI tool is never held
  against a contribution. It is reviewed like any other.
- **No one has to use AI.** Nothing in the project's workflow requires an
  AI tool, and a contribution is not expected to be faster or larger
  because such tools exist.

These rules are repeated in [AGENTS.md](AGENTS.md), which every AI agent
reads. Keep both files in step when you change them.

[charter]: https://github.com/cedricbonhomme/ai-disclosure/blob/main/AI_CHARTER.md

For a project that wrote its own, see the section of Vulnerability-Lookup.

2. AGENTS.md, for AI agents

Coding agents read this file before they work. It turns the rules into instructions, so that the trailer is added without anyone having to remember it:

AGENTS.md

## Rules for AI agents

These rules come from the "Use of AI and LLM tools" section of
[CONTRIBUTING.md](CONTRIBUTING.md). They are mandatory. CONTRIBUTING.md is
the reference, and it wins if the two files ever disagree.

- **Say so.** End every commit you author with a `Co-Authored-By` trailer
  naming the model and its version, for example:

  ```
  Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
  ```
- **Stay in scope.** Keep changes minimal and focused on the task. Do not
  reformat, rename, or rewrite unrelated code or comments.
- **Check what you produce.** Run the tests before handing your work over,
  and say plainly what you could not verify.
- **A human reviews and submits.** Never open a pull request or an issue
  on your own; the decision is the human's, after they have reviewed your
  work.
- **Report only what was reproduced.** When you help write an issue, the
  human must have observed the problem. Never present an unverified
  finding as a confirmed one.
- **Leave the human's box to the human.** When you draft a pull request
  description, keep all the sections of the template. Never tick the box
  "I have read, understood and tested every change": it is the human's own
  statement.

The full AGENTS.md of Vulnerability-Lookup.

3. CLAUDE.md and other tool files, if you use one

Only needed if a tool you use reads its own file instead of AGENTS.md. Keep one set of rules and make that file import it, so that the rules never drift apart:

CLAUDE.md

# CLAUDE.md

The instructions for AI agents live in AGENTS.md, shared by every tool.

@AGENTS.md
@CONTRIBUTING.md

4. .github/PULL_REQUEST_TEMPLATE.md, at the moment of submitting

Two boxes, at the end of the template:

.github/PULL_REQUEST_TEMPLATE.md

- [ ] Was a significant part of it generated with an AI tool? (If so, the commits carry a `Co-Authored-By` trailer naming the model.)
- [ ] I have read, understood and tested every change in this pull request, and I can explain it.

The first is a fact about the change, and it can be checked against the commits. The second is the author's own statement: an AI tool that drafts the description leaves it unticked, and the author ticks it once it is true.

Together they answer the two questions that decide the value of a contribution: was AI involved, and did a person review the result? Both ticked is ai-assisted. The first without the second is ai-autonomous, and that is not what this practice accepts.

Optional, for tools. A project that wants tools to read its rules can add a fifth file, ai-policy.yaml: a short summary of what it accepts, in a format proposed by others. This site shows it on the page of the project. The four files above remain the reference.

Adopt it

The shortest way is one paragraph. Paste it into your CONTRIBUTING.md, and the project has adopted the practice:

CONTRIBUTING.md

## Use of AI and LLM tools

This project adopts the [AI transparency charter][charter] 1.3.
AI-assisted contributions are accepted, and they are declared: end each
commit that was not written by a human with a trailer naming the model and
its version, for example:

```
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
```

[charter]: https://github.com/cedricbonhomme/ai-disclosure/blob/main/AI_CHARTER.md

The whole practice is three steps. Each one is a text to copy from the section above:

  1. Copy the section for CONTRIBUTING.md, and set the date the rules apply from.
  2. Copy the rules for AGENTS.md. If a tool you use reads its own file, such as CLAUDE.md, make that file import it.
  3. Add the two boxes to the pull request template.

Two more things are optional:

  • a summary of your rules for tools, in an ai-policy.yaml file;
  • having your project followed on this site, so that what is declared is published. Commits made before the date of the rules are shown for the history and are not held to them.

The same commitments are written as a short, versioned text, the AI transparency charter.

The limits, said plainly

The trailer and the four files are the best we have today. They are also a weak system, and it is better to say so.

  • The trailer is a line of text. Anyone can write it, forget it or remove it, and a squash or a rewritten commit message can drop it. Nothing signs it and nothing verifies it.
  • It says yes or no, not how much. A model that wrote a whole feature and a model that fixed one line leave the same trailer. Counting the lines of the commit tells how large the commit is, not which part of it the model wrote. The shared vocabulary does not measure it either: it asks whether a person reviewed the change.
  • It understates the part of the model. Git still lists a human as the author of the commit, with the AI as a co-author. In practice the model often does much of the work, and not only the code: it proposes designs, suggests features and brings ideas nobody had asked for. As we wrote when looking back at the history of Vulnerability-Lookup: "Our tools for giving credit haven't caught up with this reality yet."
  • Some disclosure is out of its reach. Not every project puts the declaration in the commit. Kubernetes asks for it in the description of the pull request, and the Linux kernel in the changelog, as plain sentences. A tool that reads trailers finds nothing there: on this site, such a project would show as "no AI declared" while its contributors declare.
  • The rules are requests. AGENTS.md and CONTRIBUTING.md ask; they cannot oblige. An agent may not read the file or may not follow it, and the person behind the agent is free to remove the trailer, or to tick a box without having read the change. A project can check that the boxes and the trailers agree. It cannot check that they are true.
  • A ban rests on the same good faith. SourceHut, which no longer accepts original content written with an LLM, states that it will not deploy "any automated tools for detecting AI use". Forbidding and declaring meet the same wall: only the contributor knows.

So the whole practice rests on good faith, and this has two consequences. The figures of this site are a lower bound: they count what was declared, never more. And declaring must cost nothing, because people only say what they are not blamed for.

Stronger systems may come, where a tool attests what it produced and the forge records it. Until then, a plain line that people agree to write is far better than silence.

What it is not

  • Not an obligation. Nothing here asks anyone to use an AI tool.
  • Not a ban. AI-assisted contributions are accepted. A project can still close a pull request nobody understood: that is about review, not about the tool.
  • Not a ranking. The pages of this site describe what is declared. A high share is not a fault and a low one is not a merit.
  • Not a proof. "No AI declared" never means "no AI used". Only a person can state human-only, and this site never states it for them.