RADV, AMD's Vulkan driver within Mesa, has adopted its own policy on the use of language models in the contributions it receives. The announcement comes on November 2 and makes the driver one of the first graphics projects to set explicit rules for a phenomenon that until now was handled case by case. It is not a ban, it is a framework on what must be declared and what is expected of whoever signs a patch.
The decision is better understood by looking at the month open source software has left behind. The Linux 7.4 merge window closed with 18,591 changes without merging, almost as many as the entire previous cycle, and Linus Torvalds himself described it as a record with part of the credit attributed to AI. OverlayFS received an unusual batch of fixes detected by automated review, and FreeRDP spoke of a flood of activity for the same reason.
The problem that appears when volume multiplies is not the quality of the generated code, it is review time. A maintainer who receives a hundred patches a week and spends twenty minutes on each has a limit that enthusiasm cannot solve. AI policies are, in practice, a mechanism for deciding who gets that scarce time.
What changes for those who submit a patch?
RADV's policy rests on a simple idea. Whoever submits a change is responsible for it, whether they wrote it by hand or with the help of a model. That means declaring the use of tools when relevant, understanding every line submitted and not delegating to the model the responsibility of knowing why the change works.
That principle seems obvious and it is not. Much of the current flow consists of generating a patch, sending it to the mailing list and waiting for someone to review it. When the patch comes from a model trained on the repository itself, the temptation to submit without understanding is high, because the text sounds plausible and compiles.
The policy also addresses traceability. If a contribution relies on generated material, the reviewer needs to know in order to gauge how much effort to devote to checking assumptions. Reviewing a change that someone has tested on their graphics card is not the same as reviewing one that comes from a statistical prediction with no real execution.
The month AI overwhelmed the repositories
October left signals at every layer. The kernel experienced its largest merge window, with a tree approaching 42 million lines, and discussions about AI stopped being theoretical and became something that appears in daily email. The RADV driver is not an exception within Mesa, it is the first to put it in writing.
The FreeRDP case is the clearest example of what can happen when the barrier to entry drops. The project went from a trickle of contributions to a volume that forced a reorganization of review work, and its version 3.33 was released with WebAssembly support and a broad set of fixes. More hands and more code, yes. And also more noise.
That noise has a specific victim. Small projects do not have a paid team to absorb the load, and their maintainers are people who review at night after their day job. When volume multiplies without an increase in the number of reviewers, review quality drops and with it the quality of the project.
The problem is not the code, it is the review
There is a common confusion in this debate. People argue about whether AI writes good code, when the relevant question is whether human reviewers can verify what they receive. A correct patch, but incomprehensible to whoever integrates it, is a debt paid later, in a failure no one can explain.
In a graphics driver that has visible consequences. A subtle change in memory handling can cause screen corruption, hangs or failures that only appear in a specific combination of GPU and game. Review in this area has always been tough, and adding volume without context makes it worse.
The policies that are emerging share a pragmatic approach. They do not ban the tool, they require the result to be understandable and verifiable by a human. It is the same logic that has been applied for years to patches submitted by companies: an organization's seal does not replace review, it only indicates who is accountable if something breaks.
The policy as a trust filter
What is interesting about RADV's decision is that it creates an admission criterion before a serious problem exists. Projects tend to react after an incident, when trust already has to be rebuilt in a hurry. Here it anticipates a situation that is already happening in the kernel and in other codebases.
It also forces a look at the less discussed side. If a company uses a model to generate contributions to an open source project, it is using someone else's infrastructure to validate its product. That is not bad in itself, but it changes the relationship between those who maintain and those who consume. Disclosure rules make that relationship visible.
It remains to be seen how much can really be verified. A reviewer cannot know whether a patch came from a model or from an afternoon of work, and honest declarations depend on the good faith of the sender. What a project can do is require that the code be defensible and punish contributions that are not with expulsion.
Mesa is not improvising. The kernel has spent months discussing how to declare the use of models in patches, and several projects have published internal guidelines before formal policies. The difference is that RADV puts it in writing in a repository anyone can read.
That gesture has a useful side effect. It turns a diffuse discussion into a criterion that can be cited, and gives reviewers an objective reason to reject a change that does not hold up. In projects with few maintainers, having a written rule saves arguments and time.
The logical place to start
Mesa occupies a peculiar position. It is critical infrastructure for anyone using Linux with graphics, it is maintained by companies with commercial interests and it receives contributions from hobbyists with very different hardware. That mix makes it a perfect laboratory for measuring the effects of AI on open development.
If the policy works in RADV, other drivers and projects in the ecosystem will copy it with adjustments. If it fails, the argument will be that the problem was not AI, it was the lack of reviewers, and the discussion will shift to who pays for that work. In both cases, what is decided here will carry more weight than an announcement about an AMD driver suggests.
The open question is not whether AI can be used to write patches, because it already is. It is whether open source software wants to remain a space where code is explained between people, with a name behind every line, or become a flow where no one knows why something works until it stops working.