Skip to contentSkip to conversation

coding-assistants: simplify attribution

RFC PATCH In review Christian Brauner 18 participants 61 messages Jul 1 – Jul 15 1 message not in the archive

Subsystems (3)
lore
Share & tools
lore

Christian Brauner

author maintainer
#0 lore raw

RFC PATCH 1/1 coding-assistants: simplify attribution

I remain very confused by our coding assistant contribution guidelines. I'm going to be a bit polemic now but this seriously in good faith.

Why precisely do we require all this detailed information about what specific coding assistant was used?

I find it very irritating that our git history has effectively started to function a bit like a free advertising platform for a bunch of AI companies and their proprietary agents and models.

And it reamins unclear to me what exactly we do get out of this detailed
information: Do we want to run statistical analysis on what agent and model is used the most and publish that on LWN at some point?

I acknowledge that my stance is even more radical: imho we would just stop it with any disclosure requirements completely. It's useless imho. We already see that other than core contributors most people don't care and will just not disclose their usage of AI. I think this is entirely pointless and worse it brings in undefined legal status as well. It's not like recent events of pulling certain models from the face of the earth have made this any less concerning.

But fine, if we want to do this can we please just dumb it down to

Assisted-by LLM

or

Assisted-by Coding Assistant

or something else. That still gives the "careful review" signal to reviewers that want to pay special attention to LLM generated work while avoiding this slew of metadata.

---
 Documentation/process/coding-assistants.rst | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)
Documentation/process/coding-assistants.rst +2 -6
index 899f4459c52d..fe34f3e7e828 100644
@@ -43,12 +43,8 @@ When AI tools contribute to kernel development, proper attribution
 helps track the evolving role of AI in the development process.
 Contributions should include an Assisted-by tag in the following format::
 
-  Assisted-by: AGENT_NAME:MODEL_VERSION [TOOL1] [TOOL2]
+  Assisted-by: LLM [TOOL1] [TOOL2]
 
-Where:
-
-* ``AGENT_NAME`` is the name of the AI tool or framework
-* ``MODEL_VERSION`` is the specific model version used
 * ``[TOOL1] [TOOL2]`` are optional specialized analysis tools used
   (e.g., coccinelle, sparse, smatch, clang-tidy)
 
@@ -56,4 +52,4 @@ Basic development tools (git, gcc, make, editors) should not be listed.
 
 Example::
 
-  Assisted-by: Claude:claude-3-opus coccinelle sparse
+  Assisted-by: LLM coccinelle sparse

---
base-commit: dc59e4fea9d83f03bad6bddf3fa2e52491777482
change-id: 20260701-work-coding-assistants-650ae1202ee0

#1 lore raw
Quoted 3 lines · Christian Brauner

And it reamins unclear to me what exactly we do get out of this detailed
information: Do we want to run statistical analysis on what agent and model is used the most and publish that on LWN at some point?

IIRC it was literally this, have people mention which tools they used so we can use that to inform our assessment of the patches. I'm not sure the differences we're actually seeing are tool based rather than operator skill though.

author maintainer
#2 lore raw
Quoted 8 lines · Mark Brown
Quoted 3 lines · Christian Brauner

And it reamins unclear to me what exactly we do get out of this detailed
information: Do we want to run statistical analysis on what agent and model is used the most and publish that on LWN at some point?

IIRC it was literally this, have people mention which tools they used so we can use that to inform our assessment of the patches. I'm not sure

Forgive my candor but I think that is just useless for us. It's certainly useful for AI company statistics. If we want to provide that service I would recommend we start charging. ;)

#3 lore raw
Quoted 7 lines · Christian Brauner
Quoted 5 lines · Mark Brown
Quoted 3 lines · Christian Brauner

And it reamins unclear to me what exactly we do get out of this detailed
information: Do we want to run statistical analysis on what agent and model is used the most and publish that on LWN at some point?

Quoted 6 lines
Quoted 2 lines

IIRC it was literally this, have people mention which tools they used so we can use that to inform our assessment of the patches. I'm not sure

Forgive my candor but I think that is just useless for us. It's certainly useful for AI company statistics. If we want to provide that service I would recommend we start charging. ;)

Yeah, that was more an observation of fact than a comment on value. Certainly now we're able to see what things look like in practice.

maintainer
#4 lore raw
In reply to Christian Brauner
Quoted 5 lines · Christian Brauner

I remain very confused by our coding assistant contribution guidelines. I'm going to be a bit polemic now but this seriously in good faith.

Why precisely do we require all this detailed information about what specific coding assistant was used?

From my memory of the discussions:

- If a specific LLM turns out to be in a bad position with regard to some copyright ruling, we can identify the commits that might have been tainted by it.

- Similarly should an LLM prove to have an inclination toward specific types of security issues.

Whether either of these would ever actually prove useful is not something I can hazard a guess for.

Quoted 7 lines

I find it very irritating that our git history has effectively started to function a bit like a free advertising platform for a bunch of AI companies and their proprietary agents and models.

And it reamins unclear to me what exactly we do get out of this detailed
information: Do we want to run statistical analysis on what agent and model is used the most and publish that on LWN at some point?

...wasn't in my plans ...

Quoted 4 lines

I acknowledge that my stance is even more radical: imho we would just stop it with any disclosure requirements completely. It's useless imho. We already see that other than core contributors most people don't care and will just not disclose their usage of AI.

The widespread ignoring of the disclosure rule is, IMO, something we need to address somehow; were I still on the TAB, I'd be raising the issue there. Either we find a way to be serious about enforcing the disclosure rule, or we should just drop it. A rule that everybody ignores is less than useful.

(That said, 706 commits in 7.2-rc1 include Assisted-by tags, so *some* people are complying. That's about 5% of the total. What do we think is the actual use of LLMs for the creation of kernel patches?)

jon

#5 lore raw
Quoted 10 lines
Quoted 4 lines

I acknowledge that my stance is even more radical: imho we would just stop it with any disclosure requirements completely. It's useless imho. We already see that other than core contributors most people don't care and will just not disclose their usage of AI.

The widespread ignoring of the disclosure rule is, IMO, something we need to address somehow; were I still on the TAB, I'd be raising the issue there. Either we find a way to be serious about enforcing the disclosure rule, or we should just drop it. A rule that everybody ignores is less than useful.

Note. :)

We do have people using it, and at least in MM, when we suspect AI usage and get the confirmation, we would tell people to use proper tags. (happens not so often IIRC)

Signature · 3 lines
Cheers,

David
#7 lore raw
In reply to Jonathan Corbet
Quoted 9 lines · Jonathan Corbet
Quoted 2 lines

Why precisely do we require all this detailed information about what specific coding assistant was used?

From my memory of the discussions:

- If a specific LLM turns out to be in a bad position with regard to some copyright ruling, we can identify the commits that might have been tainted by it.

Quoted 5 lines

- Similarly should an LLM prove to have an inclination toward specific types of security issues.

Whether either of these would ever actually prove useful is not something I can hazard a guess for.

In https://lwn.net/Articles/854645/ (An update on the UMN affair) you documented a case where an organization acted maliciously, resulting in the need to audit (and revert) numerous commits based on git authorship metadata. IMO the existing Assisted-by tags, although far from perfect, will be useful for audits when a specific LLM coding assistant is similarly found to be generating malicious output.

Thanks, David

#8 lore raw
In reply to Christian Brauner
Quoted 22 lines · Christian Brauner

I remain very confused by our coding assistant contribution guidelines. I'm going to be a bit polemic now but this seriously in good faith.

Why precisely do we require all this detailed information about what specific coding assistant was used?

I find it very irritating that our git history has effectively started to function a bit like a free advertising platform for a bunch of AI companies and their proprietary agents and models.

And it reamins unclear to me what exactly we do get out of this detailed
information: Do we want to run statistical analysis on what agent and model is used the most and publish that on LWN at some point?

I acknowledge that my stance is even more radical: imho we would just stop it with any disclosure requirements completely. It's useless imho. We already see that other than core contributors most people don't care and will just not disclose their usage of AI. I think this is entirely pointless and worse it brings in undefined legal status as well. It's not like recent events of pulling certain models from the face of the earth have made this any less concerning.

Quoted 7 lines

But fine, if we want to do this can we please just dumb it down to

Assisted-by LLM

or

Assisted-by Coding Assistant

I'd prefer this.

The doc states "proper attribution helps track the evolving role of AI in the development process". If there is another reason why we need the free advertisement, we should document it.

Side note: if someone instructs an LLM exactly what to do, and would have achieved the same thing just typing it in, the use of the tag is not any helpful to me. (similar to "Assisted-by: vim" would not be helpful).

What would be much more relevant to know is to which degree LLMs were used.

Assisted-by LLM # translate commit message
Assisted-by LLM # generate some test cases
Assisted-by LLM # cleanup logic
Assisted-by LLM # everything and I have no clue what any in here does

I thought we ask for that in some document, but couldn't immediately find it (and nobody does that).

Signature · 3 lines
Cheers,

David
author maintainer
#9 lore raw
Quoted 6 lines

What would be much more relevant to know is to which degree LLMs were used.

Assisted-by LLM # translate commit message
Assisted-by LLM # generate some test cases
Assisted-by LLM # cleanup logic
Assisted-by LLM # everything and I have no clue what any in here does

I think we should just drop any attribution as a general kernel-wide rule and let subsystems require them as needed. Then you can have all the complexity in mm for this that you think is needed for your workflow to function. This is precisely what the subsystem profiles are for. So maybe just add:

Documentation/process/maintainer-mm.rst

alongside

Documentation/process/maintainer-{tip,netdev,x86}.rst

and lay down the rules that you require for LLM based submissions in whatever detail you need.

I don't see how this additional commentary you want would ever be enforced consistently across the kernel or who would even enforce it. I don't need more beaurocracy to chase after people in my subsystems tbh.

The other thing is that I think this Assisted-by annotation is just noise in the changelog. If you want to know in detail what an LLM was used for when generating the patch it's mostly a signal for how "intense" of a review this will get afaict (already questionable imho but sure that's just something to disagree on).

If the information is mostly useful during review then I still would question why it has to end up in our git logs. It's completely irrelevant information imho.

Quoted 2 lines

I thought we ask for that in some document, but couldn't immediately find it (and nobody does that).

#10 lore raw
Quoted 13 lines · Christian Brauner
Quoted 6 lines

What would be much more relevant to know is to which degree LLMs were used.

Assisted-by LLM # translate commit message
Assisted-by LLM # generate some test cases
Assisted-by LLM # cleanup logic
Assisted-by LLM # everything and I have no clue what any in here does

I think we should just drop any attribution as a general kernel-wide rule and let subsystems require them as needed. Then you can have all the complexity in mm for this that you think is needed for your workflow to function. This is precisely what the subsystem profiles are for. So maybe just add:

Quoted 8 lines

Documentation/process/maintainer-mm.rst

alongside

Documentation/process/maintainer-{tip,netdev,x86}.rst

and lay down the rules that you require for LLM based submissions in whatever detail you need.

I'm not really sure if having (more?) subsystem-specific tags is the way to go. (below)

So either we find a very simple, kernel-wide rule for such tags, or we drop them entirely.

Quoted 4 lines

I don't see how this additional commentary you want would ever be enforced consistently across the kernel or who would even enforce it. I don't need more beaurocracy to chase after people in my subsystems tbh.

That's certainly a good thing to discuss. (below)

Quoted 6 lines

The other thing is that I think this Assisted-by annotation is just noise in the changelog. If you want to know in detail what an LLM was used for when generating the patch it's mostly a signal for how "intense" of a review this will get afaict (already questionable imho but sure that's just something to disagree on).

I'd be happy to just have such information in the cover letter. Without any tags. Having subsystem-specific rules on the disclosure on that might be more reasonable.

I agree on the "enforce" aspect. It's impossible, but it's still easy to catch people using AI irresponsibly today ... and that's what we care about. Not people that know what they are doing using AI responsibly.

Quoted 4 lines

If the information is mostly useful during review then I still would question why it has to end up in our git logs. It's completely irrelevant information imho.

Fully agreed. In the tree it's irrelevant.

Signature · 3 lines
Cheers,

David
#11 lore raw
Quoted 43 lines · David Hildenbrand (Arm)
Quoted 13 lines · Christian Brauner
Quoted 6 lines

What would be much more relevant to know is to which degree LLMs were used.

Assisted-by LLM # translate commit message
Assisted-by LLM # generate some test cases
Assisted-by LLM # cleanup logic
Assisted-by LLM # everything and I have no clue what any in here does

I think we should just drop any attribution as a general kernel-wide rule and let subsystems require them as needed. Then you can have all the complexity in mm for this that you think is needed for your workflow to function. This is precisely what the subsystem profiles are for. So maybe just add:

Quoted 8 lines

Documentation/process/maintainer-mm.rst

alongside

Documentation/process/maintainer-{tip,netdev,x86}.rst

and lay down the rules that you require for LLM based submissions in whatever detail you need.

I'm not really sure if having (more?) subsystem-specific tags is the way to go. (below)

So either we find a very simple, kernel-wide rule for such tags, or we drop them entirely.

Quoted 4 lines

I don't see how this additional commentary you want would ever be enforced consistently across the kernel or who would even enforce it. I don't need more beaurocracy to chase after people in my subsystems tbh.

That's certainly a good thing to discuss. (below)

Quoted 6 lines

The other thing is that I think this Assisted-by annotation is just noise in the changelog. If you want to know in detail what an LLM was used for when generating the patch it's mostly a signal for how "intense" of a review this will get afaict (already questionable imho but sure that's just something to disagree on).

Quoted 7 lines

I'd be happy to just have such information in the cover letter. Without any tags. Having subsystem-specific rules on the disclosure on that might be more reasonable.

I agree on the "enforce" aspect. It's impossible, but it's still easy to catch people using AI irresponsibly today ... and that's what we care about. Not people that know what they are doing using AI responsibly.

I have to reply to the "responsible" part: there's no possible ethical use of generative AI in FOSS development today.

Quoted 5 lines
Quoted 3 lines

If the information is mostly useful during review then I still would question why it has to end up in our git logs. It's completely irrelevant information imho.

Fully agreed. In the tree it's irrelevant.

Signature · 3 lines
Regards,

Laurent Pinchart
#12 lore raw
Quoted 42 lines · Laurent Pinchart
Quoted 41 lines · David Hildenbrand (Arm)
Quoted 7 lines · Christian Brauner

I think we should just drop any attribution as a general kernel-wide rule and let subsystems require them as needed. Then you can have all the complexity in mm for this that you think is needed for your workflow to function. This is precisely what the subsystem profiles are for. So maybe just add:

Quoted 8 lines

Documentation/process/maintainer-mm.rst

alongside

Documentation/process/maintainer-{tip,netdev,x86}.rst

and lay down the rules that you require for LLM based submissions in whatever detail you need.

I'm not really sure if having (more?) subsystem-specific tags is the way to go. (below)

So either we find a very simple, kernel-wide rule for such tags, or we drop them entirely.

Quoted 4 lines

I don't see how this additional commentary you want would ever be enforced consistently across the kernel or who would even enforce it. I don't need more beaurocracy to chase after people in my subsystems tbh.

That's certainly a good thing to discuss. (below)

Quoted 6 lines

The other thing is that I think this Assisted-by annotation is just noise in the changelog. If you want to know in detail what an LLM was used for when generating the patch it's mostly a signal for how "intense" of a review this will get afaict (already questionable imho but sure that's just something to disagree on).

I'd be happy to just have such information in the cover letter. Without any tags. Having subsystem-specific rules on the disclosure on that might be more reasonable.

Quoted 6 lines
Quoted 3 lines

I agree on the "enforce" aspect. It's impossible, but it's still easy to catch people using AI irresponsibly today ... and that's what we care about. Not people that know what they are doing using AI responsibly.

I have to reply to the "responsible" part: there's no possible ethical use of generative AI in FOSS development today.

haha, fair enough. I was focusing on the technical aspect.

Signature · 3 lines
Cheers,

David
#13 lore raw
In reply to David Hildenbrand (Arm)

(thanks for the cc-!)

Quoted 8 lines · David Hildenbrand (Arm)
Quoted 7 lines · Christian Brauner
Quoted 6 lines

What would be much more relevant to know is to which degree LLMs were used.

Assisted-by LLM # translate commit message
Assisted-by LLM # generate some test cases
Assisted-by LLM # cleanup logic
Assisted-by LLM # everything and I have no clue what any in here does
Quoted 5 lines
Quoted 5 lines

I think we should just drop any attribution as a general kernel-wide rule and let subsystems require them as needed. Then you can have all the complexity in mm for this that you think is needed for your workflow to function. This is precisely what the subsystem profiles are for. So maybe just add:

A single comment is complexity?

Quoted 7 lines
Quoted 7 lines

Documentation/process/maintainer-mm.rst

alongside

Documentation/process/maintainer-{tip,netdev,x86}.rst

Quoted 8 lines
Quoted 2 lines

and lay down the rules that you require for LLM based submissions in whatever detail you need.

I'm not really sure if having (more?) subsystem-specific tags is the way to go. (below)

So either we find a very simple, kernel-wide rule for such tags, or we drop them entirely.

Yup I couldn't disagree more with Christian here, the whole thing feels like trying to 'wish away' the AI issue, and now punting off to subsystem maintainers...

Subsystems impact each other. Right now I'm writing a series that changes driver code so we can enforce some sanity in mm APIs.

I've had to interact with fs code quite a bit that uses mm logic.

It's all interconnected, and one subsystem let's say going with 'let it all in' say, impacts another.

Yes some people lie about it, but having the guidelines only STRENGTHENS our position on that, and I've seen that in practice.

So yeah, sorry, I think it's beyond silly to push back on requesting somebody disclose how much of a patch/series was AI generated.

And [0] already essentially says people NEED to do this now. But that doc has been rather downplayed unfortunately I think.

Quoted 5 lines
Quoted 5 lines

I don't see how this additional commentary you want would ever be enforced consistently across the kernel or who would even enforce it. I don't need more beaurocracy to chase after people in my subsystems tbh.

Again, asking LLM submitters to write a single comment is 'beaurocracy'?

Quoted 10 lines

That's certainly a good thing to discuss. (below)

Quoted 6 lines

The other thing is that I think this Assisted-by annotation is just noise in the changelog. If you want to know in detail what an LLM was used for when generating the patch it's mostly a signal for how "intense" of a review this will get afaict (already questionable imho but sure that's just something to disagree on).

Quoted 3 lines

I'd be happy to just have such information in the cover letter. Without any tags. Having subsystem-specific rules on the disclosure on that might be more reasonable.

I disagree, I think it's important to have it standardised and simple.

If we make things vague, people won't do it. And reading through a cover letter in its AI slop entirety (and boy does it generate a LOT of text) to find the mention or not (and hey what if it's not clear?) is just objectively worse.

Quoted 4 lines

I agree on the "enforce" aspect. It's impossible, but it's still easy to catch people using AI irresponsibly today ... and that's what we care about. Not people that know what they are doing using AI responsibly.

For me it's about empowering maintainers to push back.

Quoted 7 lines
Quoted 5 lines

If the information is mostly useful during review then I still would question why it has to end up in our git logs. It's completely irrelevant information imho.

Fully agreed. In the tree it's irrelevant.

Not sure about that, if it turns out AI-generated patches are causing 95% more bugs say that's pretty useful information no?

Or if you find that a patch somebody sent from another subsystem that has a lassez faire approach to AI slop completely breaks you in some subtle way, isn't it easier to push for a revert if you see it's LLM-generated?

And is it really that egregious to include a tag? You can ignore it if you don't care.

Quoted 5 lines

--
Cheers,

David

Thanks, Lorenzo

[0]:https://docs.kernel.org/process/generated-content.html

#14 lore raw
Quoted 5 lines · Lorenzo Stoakes

(thanks for the cc-!)

Quoted 2 lines · David Hildenbrand (Arm)
Quoted 1 line · Christian Brauner
Quoted 7 lines
Quoted 5 lines
Quoted 5 lines

I think we should just drop any attribution as a general kernel-wide rule and let subsystems require them as needed. Then you can have all the complexity in mm for this that you think is needed for your workflow to function. This is precisely what the subsystem profiles are for. So maybe just add:

A single comment is complexity?

I think Christian meant more elaborate rules. More than just "If you used LLMs, disclose how you used them."

Quoted 27 lines
Quoted 6 lines

I'm not really sure if having (more?) subsystem-specific tags is the way to go. (below)

So either we find a very simple, kernel-wide rule for such tags, or we drop them entirely.

Yup I couldn't disagree more with Christian here, the whole thing feels like trying to 'wish away' the AI issue, and now punting off to subsystem maintainers...

Subsystems impact each other. Right now I'm writing a series that changes driver code so we can enforce some sanity in mm APIs.

I've had to interact with fs code quite a bit that uses mm logic.

It's all interconnected, and one subsystem let's say going with 'let it all in' say, impacts another.

Yes some people lie about it, but having the guidelines only STRENGTHENS our position on that, and I've seen that in practice.

So yeah, sorry, I think it's beyond silly to push back on requesting somebody disclose how much of a patch/series was AI generated.

And [0] already essentially says people NEED to do this now. But that doc has been rather downplayed unfortunately I think.

[...]

Quoted 5 lines
Quoted 3 lines

I agree on the "enforce" aspect. It's impossible, but it's still easy to catch people using AI irresponsibly today ... and that's what we care about. Not people that know what they are doing using AI responsibly.

For me it's about empowering maintainers to push back.

Right, but I suspect maintainers do have this power already, it's just not exercised that often on obvious AI slop yet.

Quoted 11 lines
Quoted 8 lines
Quoted 6 lines

If the information is mostly useful during review then I still would question why it has to end up in our git logs. It's completely irrelevant information imho.

Fully agreed. In the tree it's irrelevant.

Not sure about that, if it turns out AI-generated patches are causing 95% more bugs say that's pretty useful information no?

Well

a) You don't know how much AI was used. In particular, it could just slip in as the submitter tries to untangle some of the mess the AI created (so not AI's fault). Or the submitter just used it to write+translate the patch description. Really, the tag itself doesn't tell you much as it stands, which is the biggest problem I am having with it.

b) You don't catch all the cases where people didn't use the tag.

Quoted 4 lines

Or if you find that a patch somebody sent from another subsystem that has a lassez faire approach to AI slop completely breaks you in some subtle way, isn't it easier to push for a revert if you see it's LLM-generated?

The information would have to be had from the linked mailing list posting.

Given that some subsystems already started suppressing the tags when applying patches, that doesn't really help ... :/

Quoted 3 lines

And is it really that egregious to include a tag? You can ignore it if you don't care.

I hate the current tags as they are. The question I am asking myself: assume we stop using the Assisted-by for LLM stuff. What to do with the other tools? Why are LLMs suddenly no longer a tool to mention there.

Signature · 3 lines
Cheers,

David
#15 lore raw
Quoted 12 lines · David Hildenbrand (Arm)
Quoted 11 lines · Lorenzo Stoakes

(thanks for the cc-!)

Quoted 7 lines · David Hildenbrand (Arm)
Quoted 6 lines · Christian Brauner

I think we should just drop any attribution as a general kernel-wide rule and let subsystems require them as needed. Then you can have all the complexity in mm for this that you think is needed for your workflow to function. This is precisely what the subsystem profiles are for. So maybe just add:

Quoted 4 lines
Quoted 1 line

A single comment is complexity?

I think Christian meant more elaborate rules. More than just "If you used LLMs, disclose how you used them."

What's elaborate?

"Say how much of your patch is LLM written, here are some examples".

Surely?

Quoted 31 lines
Quoted 28 lines
Quoted 7 lines

I'm not really sure if having (more?) subsystem-specific tags is the way to go. (below)

So either we find a very simple, kernel-wide rule for such tags, or we drop them entirely.

Yup I couldn't disagree more with Christian here, the whole thing feels like trying to 'wish away' the AI issue, and now punting off to subsystem maintainers...

Subsystems impact each other. Right now I'm writing a series that changes driver code so we can enforce some sanity in mm APIs.

I've had to interact with fs code quite a bit that uses mm logic.

It's all interconnected, and one subsystem let's say going with 'let it all in' say, impacts another.

Yes some people lie about it, but having the guidelines only STRENGTHENS our position on that, and I've seen that in practice.

So yeah, sorry, I think it's beyond silly to push back on requesting somebody disclose how much of a patch/series was AI generated.

And [0] already essentially says people NEED to do this now. But that doc has been rather downplayed unfortunately I think.

[...]

Quoted 8 lines
Quoted 5 lines
Quoted 3 lines

I agree on the "enforce" aspect. It's impossible, but it's still easy to catch people using AI irresponsibly today ... and that's what we care about. Not people that know what they are doing using AI responsibly.

For me it's about empowering maintainers to push back.

Right, but I suspect maintainers do have this power already, it's just not exercised that often on obvious AI slop yet.

Well I certainly don't feel I do :)

I tried pushing back on obvious AI slop and got a huge amount of blow back for it because the guy wasn't honest about it.

A key reason for me pushing back on the tooling documentation was precisely because I felt we needed a clear means of doing this.

This being the part:

"As with the output of any tooling, the result may be incorrect or inappropriate. You are expected to understand and to be able to defend everything you submit. If you are unable to do so, then do not submit the resulting changes.

If you do so anyway, maintainers are entitled to reject your series without detailed review."

But if somebody denies it, no matter how strong the evidence, you can never really 'prove' it.

I think honestly if there's a newcomer who suddenly out of nowhere does a huge involved series in an area they've not touched before and LLMs assess it as 90% likely to be LLM generated,and they reply making mistakes that only an LLM would make (misinterpreting a field's symbol and then acting as if really exists) - it's not unreasonable to cite these things as a reason to 'not really trust' that it's their work.

Perhaps worded nicely to say 'sorry if I'm mistaken'?

All I'm really asking is for the ability to say something like "I reasonably believe that this is generated, so we need to build more trust here, apologies if I'm mistaken, but can we see some smaller patches in this area first" or something like this.

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 7 lines

If the information is mostly useful during review then I still would question why it has to end up in our git logs. It's completely irrelevant information imho.

Quoted 8 lines
Quoted 4 lines
Quoted 1 line

Fully agreed. In the tree it's irrelevant.

Not sure about that, if it turns out AI-generated patches are causing 95% more bugs say that's pretty useful information no?

Well

a) You don't know how much AI was used. In particular, it could just slip in as

Hence 'tell us how much was used' :)

Quoted 6 lines

the submitter tries to untangle some of the mess the AI created (so not AI's fault). Or the submitter just used it to write+translate the patch description. Really, the tag itself doesn't tell you much as it stands, which is the biggest problem I am having with it.

b) You don't catch all the cases where people didn't use the tag.

Is this arguing 'we don't have complete information so let's have no information'? Because I would say something > nothing?

Quoted 7 lines
Quoted 5 lines

Or if you find that a patch somebody sent from another subsystem that has a lassez faire approach to AI slop completely breaks you in some subtle way, isn't it easier to push for a revert if you see it's LLM-generated?

The information would have to be had from the linked mailing list posting.

That's creating a lot more work for maintainers?

You could even figure out bug rate from Fixes: tags alone using metadata.

And yes it will be imperfect but something > nothing.

Quoted 3 lines

Given that some subsystems already started suppressing the tags when applying patches, that doesn't really help ... :/

Well that's unfortunate. But something > nothing, again.

Quoted 8 lines
Quoted 4 lines

And is it really that egregious to include a tag? You can ignore it if you don't care.

I hate the current tags as they are. The question I am asking myself: assume we stop using the Assisted-by for LLM stuff. What to do with the other tools? Why are LLMs suddenly no longer a tool to mention there.

Because it turns out it's useful to have this information and more information > less information?

Quoted 5 lines

--
Cheers,

David

Thanks, Lorenzo

#16 lore raw
Quoted 1 line · Lorenzo Stoakes

"Say how much of your patch is LLM written, here are some examples".

I think the question is, did you offload understanding to the LLM, or just the creation of the patch.

I think Assisted-by gets used as an indication of "the contributor might not understand the contribution", and the patch might warrant extra scrutiny. But that's not reliable by any means.

Right or wrong, it used to be that the lack of polish in a patch was used as a poor proxy for that, but now we get polished patches from LLMs.

BR,
Jani.

Signature · 1 line
Jani Nikula, Intel
#17 lore raw
Quoted 6 lines · Jani Nikula
Quoted 1 line · Lorenzo Stoakes

"Say how much of your patch is LLM written, here are some examples".

I think the question is, did you offload understanding to the LLM, or just the creation of the patch.

Quoted 8 lines

I think Assisted-by gets used as an indication of "the contributor might not understand the contribution", and the patch might warrant extra scrutiny. But that's not reliable by any means.

Right or wrong, it used to be that the lack of polish in a patch was used as a poor proxy for that, but now we get polished patches from LLMs.

Exactly.

I think trying gatekeep patches based on whether they were LLM generated is a long-term losing battle. I prefer to focus on the value of the patches themselves and not get too wrapped up in how they were created.

The original focus of this discussion was around Assisted-by: tags though. I'd like to circle back to that:

Do we have enough consensus to drop the requirement for them? The patches that are most problematic are pretty universally unattributed anyway.

Signature · 1 line
Jeff Layton <[email protected]>
author maintainer
#18 lore raw
In reply to David Hildenbrand (Arm)
Quoted 12 lines · David Hildenbrand (Arm)
Quoted 11 lines · Lorenzo Stoakes

(thanks for the cc-!)

Quoted 7 lines · David Hildenbrand (Arm)
Quoted 6 lines · Christian Brauner

I think we should just drop any attribution as a general kernel-wide rule and let subsystems require them as needed. Then you can have all the complexity in mm for this that you think is needed for your workflow to function. This is precisely what the subsystem profiles are for. So maybe just add:

Quoted 4 lines
Quoted 1 line

A single comment is complexity?

I think Christian meant more elaborate rules. More than just "If you used LLMs, disclose how you used them."

Yes.

I'm going to follow netdev and start dropping those tags from the changelog completely too. After speaking to some bpf maintainers they also don't use the tag. So I can safely assume that 3 large subsystems don't bother with it.

So seems to me that such requirements should just move into the subsystem profiles.

I think as a global policy this has ran its course.

Quoted 6 lines
Quoted 2 lines

And is it really that egregious to include a tag? You can ignore it if you don't care.

I hate the current tags as they are. The question I am asking myself: assume we stop using the Assisted-by for LLM stuff. What to do with the other tools? Why are LLMs suddenly no longer a tool to mention there.

Tbh, I think that's equally pointless. There are also very few instances of non-AI attribution with Assisted-by.

If the tool mattered to what was done significantly then it should just be disclosed in an appropriate paragraph in the commit message. The tag itself is imho equally useless for this. I really don't need to know that you used grep or git-sed or tcpdump and it certainly doesn't need to spam the trailers.

#19 lore raw
Quoted 8 lines · Christian Brauner

Tbh, I think that's equally pointless. There are also very few instances of non-AI attribution with Assisted-by.

If the tool mattered to what was done significantly then it should just be disclosed in an appropriate paragraph in the commit message. The tag itself is imho equally useless for this. I really don't need to know that you used grep or git-sed or tcpdump and it certainly doesn't need to spam the trailers.

The attributions that matter are things like coccinelle or sed, and people do it by putting the actual script used into the commit log
which can be pretty useful. None of that is doable by a tag that
doesn't help at all.

#20 lore raw
In reply to Christian Brauner
Quoted 37 lines · Christian Brauner
Quoted 12 lines · David Hildenbrand (Arm)
Quoted 11 lines · Lorenzo Stoakes

(thanks for the cc-!)

Quoted 7 lines · David Hildenbrand (Arm)
Quoted 6 lines · Christian Brauner

I think we should just drop any attribution as a general kernel-wide rule and let subsystems require them as needed. Then you can have all the complexity in mm for this that you think is needed for your workflow to function. This is precisely what the subsystem profiles are for. So maybe just add:

Quoted 4 lines
Quoted 1 line

A single comment is complexity?

I think Christian meant more elaborate rules. More than just "If you used LLMs, disclose how you used them."

Yes.

I'm going to follow netdev and start dropping those tags from the changelog completely too. After speaking to some bpf maintainers they also don't use the tag. So I can safely assume that 3 large subsystems don't bother with it.

So seems to me that such requirements should just move into the subsystem profiles.

I think as a global policy this has ran its course.

Quoted 6 lines
Quoted 2 lines

And is it really that egregious to include a tag? You can ignore it if you don't care.

I hate the current tags as they are. The question I am asking myself: assume we stop using the Assisted-by for LLM stuff. What to do with the other tools? Why are LLMs suddenly no longer a tool to mention there.

Quoted 8 lines

Tbh, I think that's equally pointless. There are also very few instances of non-AI attribution with Assisted-by.

If the tool mattered to what was done significantly then it should just be disclosed in an appropriate paragraph in the commit message. The tag itself is imho equally useless for this. I really don't need to know that you used grep or git-sed or tcpdump and it certainly doesn't need to spam the trailers.

We've dealt with coccinelle-generated code changes for ages without Assisted-by tags and without any issue. Submitters typically include the semantic patch in the commit message, or just mentioned coccinelle was used. I personally feel that the apparent generic scope of the Assisted-by trailer tag, and the fact that this is documented in a file named generated-content.rst, is an attempt to pretend generative AI is "just another tool" comparable to coccinelle or checkpatch.

Signature · 3 lines
Regards,

Laurent Pinchart
#21 lore raw
In reply to Christian Brauner
Quoted 25 lines · Christian Brauner
Quoted 12 lines · David Hildenbrand (Arm)
Quoted 11 lines · Lorenzo Stoakes

(thanks for the cc-!)

Quoted 7 lines · David Hildenbrand (Arm)
Quoted 6 lines · Christian Brauner

I think we should just drop any attribution as a general kernel-wide rule and let subsystems require them as needed. Then you can have all the complexity in mm for this that you think is needed for your workflow to function. This is precisely what the subsystem profiles are for. So maybe just add:

Quoted 4 lines
Quoted 1 line

A single comment is complexity?

I think Christian meant more elaborate rules. More than just "If you used LLMs, disclose how you used them."

Yes.

I'm going to follow netdev and start dropping those tags from the changelog completely too. After speaking to some bpf maintainers they also don't use the tag. So I can safely assume that 3 large subsystems don't bother with it.

Quoted 4 lines

So seems to me that such requirements should just move into the subsystem profiles.

I think as a global policy this has ran its course.

I'm honestly not sure why you sent this patch in the first place if you're simply going to ignore it (+ people's opinions) anyway :)

Maybe we need a way of figuring out which patches mean something and which don't (I guess whatever Linus enforces is the real truth of that).

Anyway I guess I'll get back to work, and we can figure out what we'll do in mm separately I guess.

I'll still send a patch to link the apparently redundant AI doc to the generated tooling doc because for those who do pay attention it's silly that they're not connected.

Thanks, Lorenzo

author maintainer
#22 lore raw
Quoted 4 lines
Quoted 1 line

I think as a global policy this has ran its course.

I'm honestly not sure why you sent this patch in the first place if you're simply going to ignore it (+ people's opinions) anyway :)

I sent an RFC patch for the minimal acceptable change in my opinion. It turns out that the majority of people on here seem to prefer the removal that I mentioned as an alternative in the commit message instead and it already happens in practice.

Quoted 3 lines

I'll still send a patch to link the apparently redundant AI doc to the generated tooling doc because for those who do pay attention it's silly that they're not connected.

This on the other hand seems a bit strange given the direction of this discussion.

#23 lore raw
Quoted 9 lines · Christian Brauner
Quoted 4 lines
Quoted 1 line

I think as a global policy this has ran its course.

I'm honestly not sure why you sent this patch in the first place if you're simply going to ignore it (+ people's opinions) anyway :)

I sent an RFC patch for the minimal acceptable change in my opinion. It turns out that the majority of people on here seem to prefer the removal that I mentioned as an alternative in the commit message instead and it already happens in practice.

I made arguments as to why I felt tags were useful, linking to actual series, etc. and I feel it'd be healthier if you would respond to those points rather than vox populi.

But I guess the ship has sailed.

There's been about 1,000 Assisted-by tags since this doc was introduced at the end of December 2025, which is small (~2% of all patches) and clearly majorly underestimates the actual numbers, so 'it already happens in practice' seems a bit... inaccurate?

I also think there's a lot more frustration in 'it does nothing to prevent the flood of unacked AI slop' in the responses here, which is totally understandable.

But I think people are missing the fact it makes it easier to deal with those instances where people do ack it.

It's imperfect, it shouldn't advertise models, but it's still got actual use. If you were looking for 'do people have a use for this', then yes, we do.

Quoted 8 lines
Quoted 4 lines

I'll still send a patch to link the apparently redundant AI doc to the generated tooling doc because for those who do pay attention it's silly that they're not connected.

This on the other hand seems a bit strange given the direction of this discussion.

I don't understand that at all. The coding assistants document is not being deleted, and if you read https://docs.kernel.org/process/generated-content.html
you can see it doesn't enforce tags.

It makes reasonable points that from the sounds of it you don't disagree with? So why on earth wouldn't we link the two?

Thanks, Lorenzo

#25 lore raw
Quoted 7 lines · Christian Brauner
Quoted 3 lines

I don't understand that at all. The coding assistants document is not being deleted, and if you read https://docs.kernel.org/process/generated-content.html
you can see it doesn't enforce tags.

I think that was a misunderstanding. I just wasn't clear on what you wanted to do.

Ack ok thanks :) maybe I wasn't clear about it, really just wanting to make sure reader of one doc is aware of the other, will be a trivial patch.

Cheers, Lorenzo

#26 lore raw
In reply to Christian Brauner
Quoted 32 lines · Christian Brauner
Quoted 6 lines

What would be much more relevant to know is to which degree LLMs were used.

Assisted-by LLM # translate commit message
Assisted-by LLM # generate some test cases
Assisted-by LLM # cleanup logic
Assisted-by LLM # everything and I have no clue what any in here does

I think we should just drop any attribution as a general kernel-wide rule and let subsystems require them as needed. Then you can have all the complexity in mm for this that you think is needed for your workflow to function. This is precisely what the subsystem profiles are for. So maybe just add:

Documentation/process/maintainer-mm.rst

alongside

Documentation/process/maintainer-{tip,netdev,x86}.rst

and lay down the rules that you require for LLM based submissions in whatever detail you need.

I don't see how this additional commentary you want would ever be enforced consistently across the kernel or who would even enforce it. I don't need more beaurocracy to chase after people in my subsystems tbh.

The other thing is that I think this Assisted-by annotation is just noise in the changelog. If you want to know in detail what an LLM was used for when generating the patch it's mostly a signal for how "intense" of a review this will get afaict (already questionable imho but sure that's just something to disagree on).

Quoted 3 lines

If the information is mostly useful during review then I still would question why it has to end up in our git logs. It's completely irrelevant information imho.

Food for thought, the Kubernetes project has published a disclosure policy ([1], reported by LWN.net at [2], with a blog post explaininig it at [3]). Quoting LWN.net,

"Of note, the project requires disclosure when AI tools have been used to assist in the creation of a contribution but forbids the use of listing AI as a co-author or including "assisted-by" or "co-developed" trailers to attribute work to an LLM tool."

I personally don't see a lot of value in the Assisted-by trailer, but I would like the submitter to include the information in a place that doesn't end up in the git commit history (cover letter or below the --- line).

[1] https://www.kubernetes.dev/docs/guide/pull-requests/#ai-guidance
[2] https://lwn.net/Articles/1080144/
[3] https://kubernetes.io/blog/2026/06/26/open-source-maintainership-in-the-age-of-ai/

Quoted 2 lines
Quoted 2 lines

I thought we ask for that in some document, but couldn't immediately find it (and nobody does that).

Signature · 3 lines
Regards,

Laurent Pinchart
author maintainer
#27 lore raw
Quoted 46 lines · Laurent Pinchart
Quoted 32 lines · Christian Brauner
Quoted 6 lines

What would be much more relevant to know is to which degree LLMs were used.

Assisted-by LLM # translate commit message
Assisted-by LLM # generate some test cases
Assisted-by LLM # cleanup logic
Assisted-by LLM # everything and I have no clue what any in here does

I think we should just drop any attribution as a general kernel-wide rule and let subsystems require them as needed. Then you can have all the complexity in mm for this that you think is needed for your workflow to function. This is precisely what the subsystem profiles are for. So maybe just add:

Documentation/process/maintainer-mm.rst

alongside

Documentation/process/maintainer-{tip,netdev,x86}.rst

and lay down the rules that you require for LLM based submissions in whatever detail you need.

I don't see how this additional commentary you want would ever be enforced consistently across the kernel or who would even enforce it. I don't need more beaurocracy to chase after people in my subsystems tbh.

The other thing is that I think this Assisted-by annotation is just noise in the changelog. If you want to know in detail what an LLM was used for when generating the patch it's mostly a signal for how "intense" of a review this will get afaict (already questionable imho but sure that's just something to disagree on).

Quoted 3 lines

If the information is mostly useful during review then I still would question why it has to end up in our git logs. It's completely irrelevant information imho.

Food for thought, the Kubernetes project has published a disclosure policy ([1], reported by LWN.net at [2], with a blog post explaininig it at [3]). Quoting LWN.net,

"Of note, the project requires disclosure when AI tools have been used to assist in the creation of a contribution but forbids the use of listing AI as a co-author or including "assisted-by" or "co-developed" trailers to attribute work to an LLM tool."

Quoted 4 lines

I personally don't see a lot of value in the Assisted-by trailer, but I would like the submitter to include the information in a place that doesn't end up in the git commit history (cover letter or below the --- line).

Fwiw, way before k8s I had systemd adopt the following policy:

https://github.com/systemd/systemd/blob/main/docs/CONTRIBUTING.md#policy-on-the-use-of-large-language-models-llms-and-ai-tooling

We expect everyone contributing to systemd to fully own their contribution, be able to reason about it, be able to explain why things were done a particular way and act as the full owner of that code. AI tools are treated the same as traditional tooling like sed, awk or coccinelle.

For the purpose of this project, AI tools CANNOT be treated as author, co-author or be credited in any way that would suggest any ownership over the contribution.

The contributor should have done all the thinking, planning and understanding of the changes needed to resolve an issue or implement a new feature prior to using automated tooling to perform the grunt work.

Unguided use of those tools or the inability to prove understanding of the code contributed will result in a loss of trust in that contributor by project maintainers which can then lead to exclusion from any further contribution to the project.

As with any other submissions, authors are responsible for doing due diligence and ensuring their submissions are compatible with the project's license as documented in LICENSES/README.md.

#28 lore raw
Quoted 70 lines · Christian Brauner
Quoted 46 lines · Laurent Pinchart
Quoted 32 lines · Christian Brauner
Quoted 6 lines

What would be much more relevant to know is to which degree LLMs were used.

Assisted-by LLM # translate commit message
Assisted-by LLM # generate some test cases
Assisted-by LLM # cleanup logic
Assisted-by LLM # everything and I have no clue what any in here does

I think we should just drop any attribution as a general kernel-wide rule and let subsystems require them as needed. Then you can have all the complexity in mm for this that you think is needed for your workflow to function. This is precisely what the subsystem profiles are for. So maybe just add:

Documentation/process/maintainer-mm.rst

alongside

Documentation/process/maintainer-{tip,netdev,x86}.rst

and lay down the rules that you require for LLM based submissions in whatever detail you need.

I don't see how this additional commentary you want would ever be enforced consistently across the kernel or who would even enforce it. I don't need more beaurocracy to chase after people in my subsystems tbh.

The other thing is that I think this Assisted-by annotation is just noise in the changelog. If you want to know in detail what an LLM was used for when generating the patch it's mostly a signal for how "intense" of a review this will get afaict (already questionable imho but sure that's just something to disagree on).

Quoted 3 lines

If the information is mostly useful during review then I still would question why it has to end up in our git logs. It's completely irrelevant information imho.

Food for thought, the Kubernetes project has published a disclosure policy ([1], reported by LWN.net at [2], with a blog post explaininig it at [3]). Quoting LWN.net,

"Of note, the project requires disclosure when AI tools have been used to assist in the creation of a contribution but forbids the use of listing AI as a co-author or including "assisted-by" or "co-developed" trailers to attribute work to an LLM tool."

Quoted 4 lines

I personally don't see a lot of value in the Assisted-by trailer, but I would like the submitter to include the information in a place that doesn't end up in the git commit history (cover letter or below the --- line).

Fwiw, way before k8s I had systemd adopt the following policy:

https://github.com/systemd/systemd/blob/main/docs/CONTRIBUTING.md#policy-on-the-use-of-large-language-models-llms-and-ai-tooling

We expect everyone contributing to systemd to fully own their contribution, be able to reason about it, be able to explain why things were done a particular way and act as the full owner of that code. AI tools are treated the same as traditional tooling like sed, awk or coccinelle.

For the purpose of this project, AI tools CANNOT be treated as author, co-author or be credited in any way that would suggest any ownership over the contribution.

The contributor should have done all the thinking, planning and understanding of the changes needed to resolve an issue or implement a new feature prior to using automated tooling to perform the grunt work.

Quoted 10 lines

Unguided use of those tools or the inability to prove understanding of the code contributed will result in a loss of trust in that contributor by project maintainers which can then lead to exclusion from any further contribution to the project.

As with any other submissions, authors are responsible for doing due diligence and ensuring their submissions are compatible with the project's license as documented in LICENSES/README.md.

This sounds very reasonable to me.

#29 lore raw
In reply to David Hildenbrand (Arm)
Quoted 25 lines · David Hildenbrand (Arm)
Quoted 24 lines · Christian Brauner

I remain very confused by our coding assistant contribution guidelines. I'm going to be a bit polemic now but this seriously in good faith.

Why precisely do we require all this detailed information about what specific coding assistant was used?

I find it very irritating that our git history has effectively started to function a bit like a free advertising platform for a bunch of AI companies and their proprietary agents and models.

And it reamins unclear to me what exactly we do get out of this detailed
information: Do we want to run statistical analysis on what agent and model is used the most and publish that on LWN at some point?

I acknowledge that my stance is even more radical: imho we would just stop it with any disclosure requirements completely. It's useless imho. We already see that other than core contributors most people don't care and will just not disclose their usage of AI. I think this is entirely pointless and worse it brings in undefined legal status as well. It's not like recent events of pulling certain models from the face of the earth have made this any less concerning.

But fine, if we want to do this can we please just dumb it down to

Quoted 7 lines
Quoted 5 lines
Assisted-by LLM

or

Assisted-by Coding Assistant

I'd prefer this.

Yeah I don't see any reason why we need to know precisely which model or version of said model we need.

Quoted 4 lines

The doc states "proper attribution helps track the evolving role of AI in the development process". If there is another reason why we need the free advertisement, we should document it.

Yup.

Honestly I find the phrasing here quite vague.

While it is interesting to track the degree of AI involvement (where that's disclosed) a really important part of this is how maintainers deal with AI submissions.

Also we have a schism in the documentation anyway, there's [0] which is literally indexed as 'AI Coding Assistants', which says NOTHING about how people are supposed to use them etc. and there's [1] Which DOES say something about that, but which isn't linked to by [0], nor links to it.

Before I happened across this thread, I was thinking of sending a patch to at least link one to the other. Now I think I definitely will.

Quoted 6 lines

Side note: if someone instructs an LLM exactly what to do, and would have achieved the same thing just typing it in, the use of the tag is not any helpful to me. (similar to "Assisted-by: vim" would not be helpful).

What would be much more relevant to know is to which degree LLMs were used.

As I mentioned off-list I do agree that this is key.

Having this information helps with the most important issue we face when it comes to AI - an EXISTENTIAL issue actually IMO - the asymmetry between how much code can be generated, and available maintainer/reviewer resource.

Being able to, at a glance, see that a series was both wholly generated seems substandard means we can quickly ask for more human attention.

And I know what the argument's going to be - 'bad faith people will lie about it' - and sure, yes they will.

But now that there's been a huge surge of AI generated code in mm I can speak from experience - many DO attribute, and for those that don't it's very useful to have guidelines to point to.

Both aid in dealing with this asymmetry.

(as an example, I've had to push back quite strongly on an _attributed_ series ([2] and [3]) that appeared to be wholly generated. Having this information would have helped there).

Quoted 5 lines
Assisted-by LLM # translate commit message
Assisted-by LLM # generate some test cases
Assisted-by LLM # cleanup logic
Assisted-by LLM # everything and I have no clue what any in here does

Yeah this format works I think!

Quoted 3 lines

I thought we ask for that in some document, but couldn't immediately find it (and nobody does that).

Well you're probably thinking of [1], e.g.:

Second, when making a contribution, be transparent about the origin of content in cover letters and changelogs. You can be more transparent by adding information like this:

...

- Which portions of the content were affected by that tool?

...

And also from the same document:

If tools permit you to generate a contribution automatically, expect additional scrutiny in proportion to how much of it was generated.

As with the output of any tooling, the result may be incorrect or inappropriate. You are expected to understand and to be able to defend everything you submit. If you are unable to do so, then do not submit the resulting changes.

If you do so anyway, maintainers are entitled to reject your series without detailed review.

This only speaks more to the need to link the two documents together. I'll send a patch.

Quoted 5 lines

--
Cheers,

David

Thanks, Lorenzo

[0]:https://docs.kernel.org/process/coding-assistants.html [1]:https://docs.kernel.org/process/generated-content.html [2]:https://lore.kernel.org/linux-mm/aj9yrlB0TrlYCLlf@lucifer/ [3]:https://lore.kernel.org/linux-mm/akIjA_dqh4OHAYo4@lucifer/

#30 lore raw
In reply to Christian Brauner
Quoted 65 lines · Christian Brauner

I remain very confused by our coding assistant contribution guidelines. I'm going to be a bit polemic now but this seriously in good faith.

Why precisely do we require all this detailed information about what specific coding assistant was used?

I find it very irritating that our git history has effectively started to function a bit like a free advertising platform for a bunch of AI companies and their proprietary agents and models.

And it reamins unclear to me what exactly we do get out of this detailed
information: Do we want to run statistical analysis on what agent and model is used the most and publish that on LWN at some point?

I acknowledge that my stance is even more radical: imho we would just stop it with any disclosure requirements completely. It's useless imho. We already see that other than core contributors most people don't care and will just not disclose their usage of AI. I think this is entirely pointless and worse it brings in undefined legal status as well. It's not like recent events of pulling certain models from the face of the earth have made this any less concerning.

But fine, if we want to do this can we please just dumb it down to

Assisted-by LLM

or

Assisted-by Coding Assistant

or something else. That still gives the "careful review" signal to reviewers that want to pay special attention to LLM generated work while avoiding this slew of metadata.

---
 Documentation/process/coding-assistants.rst | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)
Documentation/process/coding-assistants.rst +2 -7
index 899f4459c52d..fe34f3e7e828 100644
@@ -43,12 +43,8 @@ When AI tools contribute to kernel development, proper attribution
 helps track the evolving role of AI in the development process.
 Contributions should include an Assisted-by tag in the following format::
 
-  Assisted-by: AGENT_NAME:MODEL_VERSION [TOOL1] [TOOL2]
+  Assisted-by: LLM [TOOL1] [TOOL2]
 
-Where:
-
-* ``AGENT_NAME`` is the name of the AI tool or framework
-* ``MODEL_VERSION`` is the specific model version used
 * ``[TOOL1] [TOOL2]`` are optional specialized analysis tools used
   (e.g., coccinelle, sparse, smatch, clang-tidy)
 
@@ -56,4 +52,4 @@ Basic development tools (git, gcc, make, editors) should not be listed.
 
 Example::
 
-  Assisted-by: Claude:claude-3-opus coccinelle sparse
+  Assisted-by: LLM coccinelle sparse
 
---
Quoted 2 lines

base-commit: dc59e4fea9d83f03bad6bddf3fa2e52491777482
change-id: 20260701-work-coding-assistants-650ae1202ee0

In general, collecting data for nebulous purposes usually turns out to be a bad idea. If we're not 100% clear on why we want this data, then we're probably better off not collecting it at all.

With that in mind: if we're going to water down the tag, then I say just remove the requirement altogether. If we later decide that we want to start collecting more detailed info for some (clear) purpose then we can revisit the idea.

Signature · 1 line
Jeff Layton <[email protected]>
#31 lore raw
Quoted 10 lines · On Wed, 01 Jul 2026 14:35:08 -0400 Jeff Layton wrote:
Quoted 9 lines · Christian Brauner

I remain very confused by our coding assistant contribution guidelines. I'm going to be a bit polemic now but this seriously in good faith.

Why precisely do we require all this detailed information about what specific coding assistant was used?

I find it very irritating that our git history has effectively started to function a bit like a free advertising platform for a bunch of AI companies and their proprietary agents and models.

FWIW, this is exactly how I feel. I added a regex to strip these in my git hooks. So at least the net/ history should be ads-free 🤷️

Inexperienced developers who just trust the LLM output, and therefore are the group where the tags would be most useful, tend not to add them. Either because they are ashamed or because they want full credit. This correlation kills the utility of the tag.

Quoted 63 lines
Quoted 55 lines

And it reamins unclear to me what exactly we do get out of this detailed
information: Do we want to run statistical analysis on what agent and model is used the most and publish that on LWN at some point?

I acknowledge that my stance is even more radical: imho we would just stop it with any disclosure requirements completely. It's useless imho. We already see that other than core contributors most people don't care and will just not disclose their usage of AI. I think this is entirely pointless and worse it brings in undefined legal status as well. It's not like recent events of pulling certain models from the face of the earth have made this any less concerning.

But fine, if we want to do this can we please just dumb it down to

Assisted-by LLM

or

Assisted-by Coding Assistant

or something else. That still gives the "careful review" signal to reviewers that want to pay special attention to LLM generated work while avoiding this slew of metadata.

---
 Documentation/process/coding-assistants.rst | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)
Documentation/process/coding-assistants.rst +2 -7
index 899f4459c52d..fe34f3e7e828 100644
@@ -43,12 +43,8 @@ When AI tools contribute to kernel development, proper attribution
 helps track the evolving role of AI in the development process.
 Contributions should include an Assisted-by tag in the following format::
 
-  Assisted-by: AGENT_NAME:MODEL_VERSION [TOOL1] [TOOL2]
+  Assisted-by: LLM [TOOL1] [TOOL2]
 
-Where:
-
-* ``AGENT_NAME`` is the name of the AI tool or framework
-* ``MODEL_VERSION`` is the specific model version used
 * ``[TOOL1] [TOOL2]`` are optional specialized analysis tools used
   (e.g., coccinelle, sparse, smatch, clang-tidy)
 
@@ -56,4 +52,4 @@ Basic development tools (git, gcc, make, editors) should not be listed.
 
 Example::
 
-  Assisted-by: Claude:claude-3-opus coccinelle sparse
+  Assisted-by: LLM coccinelle sparse
 
---
Quoted 2 lines

base-commit: dc59e4fea9d83f03bad6bddf3fa2e52491777482
change-id: 20260701-work-coding-assistants-650ae1202ee0

In general, collecting data for nebulous purposes usually turns out to be a bad idea. If we're not 100% clear on why we want this data, then we're probably better off not collecting it at all.

Quoted 4 lines

With that in mind: if we're going to water down the tag, then I say just remove the requirement altogether. If we later decide that we want to start collecting more detailed info for some (clear) purpose then we can revisit the idea.

+1

Honestly even tool attribution feels increasingly moot. People vibe code tools and AI-in-the-loop pipelines which they never publish. Open source tools are (hopefully?) used in pre-commit pipelines, so they have the "kbuild bot problem" of problems getting fixed before the code is merged. And we have the same free advertising problem for the rest.

It's 100 times more important to drill into people to provide sufficient information in plain English. How was the bug discovered, has it been triggered / proven and how, what is the user impact. I wonder if inventing tags distracts contributors from what really matters.

author maintainer
#32 lore raw
Quoted 8 lines · Jakub Kicinski
Quoted 7 lines · On Wed, 01 Jul 2026 14:35:08 -0400 Jeff Layton wrote:
Quoted 6 lines · Christian Brauner

I remain very confused by our coding assistant contribution guidelines. I'm going to be a bit polemic now but this seriously in good faith.

Why precisely do we require all this detailed information about what specific coding assistant was used?

Quoted 6 lines
Quoted 3 lines
Quoted 3 lines

I find it very irritating that our git history has effectively started to function a bit like a free advertising platform for a bunch of AI companies and their proprietary agents and models.

FWIW, this is exactly how I feel. I added a regex to strip these in my git hooks. So at least the net/ history should be ads-free 🤷️

Ah, that's good to know. I've been rewriting them to "LLM" but I might just start doing what netdev is.

Quoted 9 lines
Quoted 8 lines

In general, collecting data for nebulous purposes usually turns out to be a bad idea. If we're not 100% clear on why we want this data, then we're probably better off not collecting it at all.

With that in mind: if we're going to water down the tag, then I say just remove the requirement altogether. If we later decide that we want to start collecting more detailed info for some (clear) purpose then we can revisit the idea.

Quoted 8 lines

+1

Honestly even tool attribution feels increasingly moot. People vibe code tools and AI-in-the-loop pipelines which they never publish. Open source tools are (hopefully?) used in pre-commit pipelines, so they have the "kbuild bot problem" of problems getting fixed before the code is merged. And we have the same free advertising problem for the rest.

Agreed.

author maintainer
#33 lore raw
In reply to Jeff Layton
Quoted 65 lines · Jeff Layton
Quoted 64 lines · Christian Brauner

I remain very confused by our coding assistant contribution guidelines. I'm going to be a bit polemic now but this seriously in good faith.

Why precisely do we require all this detailed information about what specific coding assistant was used?

I find it very irritating that our git history has effectively started to function a bit like a free advertising platform for a bunch of AI companies and their proprietary agents and models.

And it reamins unclear to me what exactly we do get out of this detailed
information: Do we want to run statistical analysis on what agent and model is used the most and publish that on LWN at some point?

I acknowledge that my stance is even more radical: imho we would just stop it with any disclosure requirements completely. It's useless imho. We already see that other than core contributors most people don't care and will just not disclose their usage of AI. I think this is entirely pointless and worse it brings in undefined legal status as well. It's not like recent events of pulling certain models from the face of the earth have made this any less concerning.

But fine, if we want to do this can we please just dumb it down to

Assisted-by LLM

or

Assisted-by Coding Assistant

or something else. That still gives the "careful review" signal to reviewers that want to pay special attention to LLM generated work while avoiding this slew of metadata.

---
 Documentation/process/coding-assistants.rst | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)
Documentation/process/coding-assistants.rst +2 -6
index 899f4459c52d..fe34f3e7e828 100644
@@ -43,12 +43,8 @@ When AI tools contribute to kernel development, proper attribution
 helps track the evolving role of AI in the development process.
 Contributions should include an Assisted-by tag in the following format::
 
-  Assisted-by: AGENT_NAME:MODEL_VERSION [TOOL1] [TOOL2]
+  Assisted-by: LLM [TOOL1] [TOOL2]
 
-Where:
-
-* ``AGENT_NAME`` is the name of the AI tool or framework
-* ``MODEL_VERSION`` is the specific model version used
 * ``[TOOL1] [TOOL2]`` are optional specialized analysis tools used
   (e.g., coccinelle, sparse, smatch, clang-tidy)
 
@@ -56,4 +52,4 @@ Basic development tools (git, gcc, make, editors) should not be listed.
 
 Example::
 
-  Assisted-by: Claude:claude-3-opus coccinelle sparse
+  Assisted-by: LLM coccinelle sparse
Quoted 8 lines
Quoted 3 lines

---
base-commit: dc59e4fea9d83f03bad6bddf3fa2e52491777482
change-id: 20260701-work-coding-assistants-650ae1202ee0

In general, collecting data for nebulous purposes usually turns out to be a bad idea. If we're not 100% clear on why we want this data, then we're probably better off not collecting it at all.

Agreed.

Quoted 4 lines

With that in mind: if we're going to water down the tag, then I say just remove the requirement altogether. If we later decide that we want to start collecting more detailed info for some (clear) purpose then we can revisit the idea.

Agreed.

#34 lore raw
In reply to Christian Brauner

Ah, I still reigniting this discussion again :)

What about a combination of what David and Jeff say? The whole point seems to me that the salient information is not that an LLM was used (or are we going to tag Sashiko as well or any other LLM-based code review tool?), but what is was used to do. This information may be relevant for how the review is approached. The latter should perhaps only be in the cover letter and then we can drop the assisted-by tags altogether.

The question about enforcement remains.

#35 lore raw
Quoted 10 lines · Jori Koolstra

Ah, I still reigniting this discussion again :)

What about a combination of what David and Jeff say? The whole point seems to me that the salient information is not that an LLM was used (or are we going to tag Sashiko as well or any other LLM-based code review tool?), but what is was used to do. This information may be relevant for how the review is approached. The latter should perhaps only be in the cover letter and then we can drop the assisted-by tags altogether.

The question about enforcement remains.

It's not possible to enforce it. People can deny it if the tag is missing and you confront them and even though the submission has many signs of being obviously LLM, there is no definite proof. We've seen (likely, as there's no proof!) that happen in mm.

Such situation then penalizes those who disclose so obviously they won't. We should drop the tag and instead think how we can empower maintainers to be able to use their own judgment and deprioritize dealing with what they perceive as LLM slop, without fearing consequences of not being properly responsible etc, and not rely on any non-enforceable tags for that.

#36 lore raw
Quoted 14 lines

Op 02-07-2026 10:44 CEST schreef Vlastimil Babka (SUSE) <[email protected]>:

Quoted 9 lines · Jori Koolstra

Ah, I still reigniting this discussion again :)

What about a combination of what David and Jeff say? The whole point seems to me that the salient information is not that an LLM was used (or are we going to tag Sashiko as well or any other LLM-based code review tool?), but what is was used to do. This information may be relevant for how the review is approached. The latter should perhaps only be in the cover letter and then we can drop the assisted-by tags altogether.

Quoted 7 lines
Quoted 1 line

The question about enforcement remains.

It's not possible to enforce it. People can deny it if the tag is missing and you confront them and even though the submission has many signs of being obviously LLM, there is no definite proof. We've seen (likely, as there's no proof!) that happen in mm.

Maintainers should be free to ignore what they perceive as slop without needing to defend that call. Reputation can be gained by submitting useful work or being present in the community, attending conferences, giving talks, etc. I am not saying that we should be harsh on beginning contributors (or I would have to count myself out as well), but they should be as free as possible to only invest their time in the project and people that may become involved in the community. And that call is up to them.

I try to review fix-up patches of first-time contributors, but if it reeks of AI I don't bother. We have the same policy in the kernel mentorship program, we invest time to help people get involved with the community and kernel, not to let someone strike "kernel contributor" of their list. The whole point is not that most of this clean-up work is super useful (and indeed an LLM can do it), but to let someone feel excited about contributing and maybe getting them to to stick around.

Quoted 5 lines

Such situation then penalizes those who disclose so obviously they won't. We should drop the tag and instead think how we can empower maintainers to be able to use their own judgment and deprioritize dealing with what they perceive as LLM slop, without fearing consequences of not being properly responsible etc, and not rely on any non-enforceable tags for that.

#37 lore raw
Quoted 22 lines · Jori Koolstra
Quoted 14 lines

Op 02-07-2026 10:44 CEST schreef Vlastimil Babka (SUSE) <[email protected]>:

Quoted 9 lines · Jori Koolstra

Ah, I still reigniting this discussion again :)

What about a combination of what David and Jeff say? The whole point seems to me that the salient information is not that an LLM was used (or are we going to tag Sashiko as well or any other LLM-based code review tool?), but what is was used to do. This information may be relevant for how the review is approached. The latter should perhaps only be in the cover letter and then we can drop the assisted-by tags altogether.

Quoted 7 lines
Quoted 1 line

The question about enforcement remains.

It's not possible to enforce it. People can deny it if the tag is missing and you confront them and even though the submission has many signs of being obviously LLM, there is no definite proof. We've seen (likely, as there's no proof!) that happen in mm.

Quoted 7 lines

Maintainers should be free to ignore what they perceive as slop without needing to defend that call. Reputation can be gained by submitting useful work or being present in the community, attending conferences, giving talks, etc. I am not saying that we should be harsh on beginning contributors (or I would have to count myself out as well), but they should be as free as possible to only invest their time in the project and people that may become involved in the community. And that call is up to them.

Yup agreed, however I have had the experience of doing exactly this and then being second-guessed enormously, which was exhausting honestly.

So we need total clarity that it's OK to do this.

I guess this is partly a subsystem-by-subsystem thing though.

Quoted 8 lines

I try to review fix-up patches of first-time contributors, but if it reeks of AI I don't bother. We have the same policy in the kernel mentorship program, we invest time to help people get involved with the community and kernel, not to let someone strike "kernel contributor" of their list. The whole point is not that most of this clean-up work is super useful (and indeed an LLM can do it), but to let someone feel excited about contributing and maybe getting them to to stick around.

Yup agreed :)

Quoted 6 lines
Quoted 6 lines

Such situation then penalizes those who disclose so obviously they won't. We should drop the tag and instead think how we can empower maintainers to be able to use their own judgment and deprioritize dealing with what they perceive as LLM slop, without fearing consequences of not being properly responsible etc, and not rely on any non-enforceable tags for that.

Thanks, Lorenzo

#38 lore raw
In reply to Vlastimil Babka (SUSE)
Quoted 10 lines · Vlastimil Babka (SUSE)
Quoted 9 lines · Jori Koolstra

Ah, I still reigniting this discussion again :)

What about a combination of what David and Jeff say? The whole point seems to me that the salient information is not that an LLM was used (or are we going to tag Sashiko as well or any other LLM-based code review tool?), but what is was used to do. This information may be relevant for how the review is approached. The latter should perhaps only be in the cover letter and then we can drop the assisted-by tags altogether.

Quoted 6 lines
Quoted 1 line

The question about enforcement remains.

It's not possible to enforce it. People can deny it if the tag is missing and you confront them and even though the submission has many signs of being obviously LLM, there is no definite proof. We've seen (likely, as there's no proof!) that happen in mm.

I think it's helpful to point to guidelines, and I've actively used that in practice with the recent wave of AI slop in mm.

But yes it quickly becomes very politically difficult if somebody adamently lies about that, and as you know I've found myself in that situation too :)

However, there are those who _do_ attribute, especially those working at tech companies that are encouraging LLM-usage, and others who are in good faith, so having the tag is, I think, helpful.

It also strengthens the case for those who are dishonest if we do at some point institute a 'well this seems very likely to be so sorry no' approach in mm at least.

Quoted 6 lines

Such situation then penalizes those who disclose so obviously they won't. We should drop the tag and instead think how we can empower maintainers to be able to use their own judgment and deprioritize dealing with what they perceive as LLM slop, without fearing consequences of not being properly responsible etc, and not rely on any non-enforceable tags for that.

I agree we should have the ability to do this.

But the amount of time wasted on AI slop is already too much and we're only at the start of this, we really need a very low effort way to filter it.

Tags with more information WILL help IMO, but I honestly think, in the long run, we're simply going to have to deprioritise patches from newcomers that do more than small changes.

Other open source communities are ahead of us in this and that seems to be the road being taken often (e.g. [0]).

Cheers, Lorenzo

[0]:https://godotengine.org/article/contribution-policy-2026/

#39 lore raw
In reply to Vlastimil Babka (SUSE)
Quoted 10 lines · Vlastimil Babka (SUSE)
Quoted 9 lines · Jori Koolstra

Ah, I still reigniting this discussion again :)

What about a combination of what David and Jeff say? The whole point seems to me that the salient information is not that an LLM was used (or are we going to tag Sashiko as well or any other LLM-based code review tool?), but what is was used to do. This information may be relevant for how the review is approached. The latter should perhaps only be in the cover letter and then we can drop the assisted-by tags altogether.

Quoted 8 lines
Quoted 1 line

The question about enforcement remains.

It's not possible to enforce it. People can deny it if the tag is missing and you confront them and even though the submission has many signs of being obviously LLM, there is no definite proof. We've seen (likely, as there's no proof!) that happen in mm.

Such situation then penalizes those who disclose so obviously they won't.

I think there's also a penality for those who don't disclose when they're told they should: it will lower trust. Kernel development is largely based on a trust model. If a contributor decides to adopt a deceiptful behaviour, they can expect maintainers to raise the bar for accepting patches, when not rejecting them outright.

I can't quantifying which of the penalities will be higher, but I hope (call me naive if you wish) that the vast majority of contributurs who *know* we require disclosure to abide by that rule, even if it incurs a penalty. After all, proponents for LLM usage claim such performance improvements that a small penalty during review can't be that bad, right ? :-)

Quoted 5 lines

We
should drop the tag and instead think how we can empower maintainers to be able to use their own judgment and deprioritize dealing with what they perceive as LLM slop, without fearing consequences of not being properly responsible etc, and not rely on any non-enforceable tags for that.

Signature · 3 lines
Regards,

Laurent Pinchart
#40 lore raw
Quoted 18 lines · Laurent Pinchart
Quoted 17 lines · Vlastimil Babka (SUSE)
Quoted 10 lines · Jori Koolstra

Ah, I still reigniting this discussion again :)

What about a combination of what David and Jeff say? The whole point seems to me that the salient information is not that an LLM was used (or are we going to tag Sashiko as well or any other LLM-based code review tool?), but what is was used to do. This information may be relevant for how the review is approached. The latter should perhaps only be in the cover letter and then we can drop the assisted-by tags altogether.

The question about enforcement remains.

It's not possible to enforce it. People can deny it if the tag is missing and you confront them and even though the submission has many signs of being obviously LLM, there is no definite proof. We've seen (likely, as there's no proof!) that happen in mm.

Quoted 7 lines
Quoted 1 line

Such situation then penalizes those who disclose so obviously they won't.

I think there's also a penality for those who don't disclose when they're told they should: it will lower trust. Kernel development is largely based on a trust model. If a contributor decides to adopt a deceiptful behaviour, they can expect maintainers to raise the bar for accepting patches, when not rejecting them outright.

Yes, I explicitly said this in response to somebody for whom there was overwhelming evidence they were submitting AI slop, and that they'd need to build it back up again.

It's precisely the issue as I see it.

But others within the community disagreed with me, so it turned into a very long and draining discussion that I don't particularly wish to repeat.

So we really need clarity on it being OK to do this (I remember saying this last year when I made an ultimately unsuccessful submission to the maintainer's summit about all this :)

What matters overall is being able to _quickly_ dismiss AI slop so that asymmetry between LLM generation + maintainer time isn't exploited.

And ultimately I think the trust model will end up being 'newcomes have 0, now build it up'.

Which sucks but this issue is simply existential for open source.

Quoted 14 lines

I can't quantifying which of the penalities will be higher, but I hope (call me naive if you wish) that the vast majority of contributurs who *know* we require disclosure to abide by that rule, even if it incurs a penalty. After all, proponents for LLM usage claim such performance improvements that a small penalty during review can't be that bad, right ? :-)

Quoted 5 lines

We
should drop the tag and instead think how we can empower maintainers to be able to use their own judgment and deprioritize dealing with what they perceive as LLM slop, without fearing consequences of not being properly responsible etc, and not rely on any non-enforceable tags for that.

Quoted 4 lines

--
Regards,

Laurent Pinchart

Thanks, Lorenzo

#41 lore raw
Quoted 40 lines · Lorenzo Stoakes
Quoted 18 lines · Laurent Pinchart
Quoted 17 lines · Vlastimil Babka (SUSE)
Quoted 10 lines · Jori Koolstra

Ah, I still reigniting this discussion again :)

What about a combination of what David and Jeff say? The whole point seems to me that the salient information is not that an LLM was used (or are we going to tag Sashiko as well or any other LLM-based code review tool?), but what is was used to do. This information may be relevant for how the review is approached. The latter should perhaps only be in the cover letter and then we can drop the assisted-by tags altogether.

The question about enforcement remains.

It's not possible to enforce it. People can deny it if the tag is missing and you confront them and even though the submission has many signs of being obviously LLM, there is no definite proof. We've seen (likely, as there's no proof!) that happen in mm.

Quoted 7 lines
Quoted 1 line

Such situation then penalizes those who disclose so obviously they won't.

I think there's also a penality for those who don't disclose when they're told they should: it will lower trust. Kernel development is largely based on a trust model. If a contributor decides to adopt a deceiptful behaviour, they can expect maintainers to raise the bar for accepting patches, when not rejecting them outright.

Yes, I explicitly said this in response to somebody for whom there was overwhelming evidence they were submitting AI slop, and that they'd need to build it back up again.

It's precisely the issue as I see it.

But others within the community disagreed with me, so it turned into a very long and draining discussion that I don't particularly wish to repeat.

So we really need clarity on it being OK to do this (I remember saying this last year when I made an ultimately unsuccessful submission to the maintainer's summit about all this :)

Quoted 8 lines

What matters overall is being able to _quickly_ dismiss AI slop so that asymmetry between LLM generation + maintainer time isn't exploited.

And ultimately I think the trust model will end up being 'newcomes have 0, now build it up'.

Which sucks but this issue is simply existential for open source.

Has anybody tried throwing any of the obvious LLM slop submissions we have seen into one of these LLM detector things? To be clear, I've never tried those so I'm certainly no authority on if they even work reliably, but if so I wonder if something like that is a potential solution for elminating the worst cases..

I.e., suppose we had some Sashiko type LLM/bot whose job was mainly to detect purely LLM generated content based on some minimum level of confidence and reply with a loud and clear message to the thread. Maybe that would be a clear enough signal to maintainers and reviewers that something is not worth prioritizing for review.. Maybe also some "slop detected" feedback would help disincentivize flinging slop onto the lists. At the very least that could be something that is more easily configured/enabled per-subsystem without having to use per-subsystem commit tags.

Brian

Quoted 21 lines
Quoted 14 lines

I can't quantifying which of the penalities will be higher, but I hope (call me naive if you wish) that the vast majority of contributurs who *know* we require disclosure to abide by that rule, even if it incurs a penalty. After all, proponents for LLM usage claim such performance improvements that a small penalty during review can't be that bad, right ? :-)

Quoted 5 lines

We
should drop the tag and instead think how we can empower maintainers to be able to use their own judgment and deprioritize dealing with what they perceive as LLM slop, without fearing consequences of not being properly responsible etc, and not rely on any non-enforceable tags for that.

Quoted 4 lines

--
Regards,

Laurent Pinchart

Thanks, Lorenzo

#42 lore raw
Quoted 56 lines · Brian Foster
Quoted 40 lines · Lorenzo Stoakes
Quoted 18 lines · Laurent Pinchart
Quoted 17 lines · Vlastimil Babka (SUSE)
Quoted 10 lines · Jori Koolstra

Ah, I still reigniting this discussion again :)

What about a combination of what David and Jeff say? The whole point seems to me that the salient information is not that an LLM was used (or are we going to tag Sashiko as well or any other LLM-based code review tool?), but what is was used to do. This information may be relevant for how the review is approached. The latter should perhaps only be in the cover letter and then we can drop the assisted-by tags altogether.

The question about enforcement remains.

It's not possible to enforce it. People can deny it if the tag is missing and you confront them and even though the submission has many signs of being obviously LLM, there is no definite proof. We've seen (likely, as there's no proof!) that happen in mm.

Quoted 7 lines
Quoted 1 line

Such situation then penalizes those who disclose so obviously they won't.

I think there's also a penality for those who don't disclose when they're told they should: it will lower trust. Kernel development is largely based on a trust model. If a contributor decides to adopt a deceiptful behaviour, they can expect maintainers to raise the bar for accepting patches, when not rejecting them outright.

Yes, I explicitly said this in response to somebody for whom there was overwhelming evidence they were submitting AI slop, and that they'd need to build it back up again.

It's precisely the issue as I see it.

But others within the community disagreed with me, so it turned into a very long and draining discussion that I don't particularly wish to repeat.

So we really need clarity on it being OK to do this (I remember saying this last year when I made an ultimately unsuccessful submission to the maintainer's summit about all this :)

Quoted 8 lines

What matters overall is being able to _quickly_ dismiss AI slop so that asymmetry between LLM generation + maintainer time isn't exploited.

And ultimately I think the trust model will end up being 'newcomes have 0, now build it up'.

Which sucks but this issue is simply existential for open source.

Has anybody tried throwing any of the obvious LLM slop submissions we have seen into one of these LLM detector things? To be clear, I've never tried those so I'm certainly no authority on if they even work reliably, but if so I wonder if something like that is a potential solution for elminating the worst cases..

Quoted 9 lines

I.e., suppose we had some Sashiko type LLM/bot whose job was mainly to detect purely LLM generated content based on some minimum level of confidence and reply with a loud and clear message to the thread. Maybe that would be a clear enough signal to maintainers and reviewers that something is not worth prioritizing for review.. Maybe also some "slop detected" feedback would help disincentivize flinging slop onto the lists. At the very least that could be something that is more easily configured/enabled per-subsystem without having to use per-subsystem commit tags.

Yup I thought of this, have done this on series and they do detect it reliably.

But then it becomes an arms race. People will get AI to try to defeat AI detection. So I'm not sure it's a safe road to go down.

Quoted 3 lines

Brian

Thanks, Lorenzo

#43 lore raw
Quoted 67 lines · Lorenzo Stoakes
Quoted 56 lines · Brian Foster
Quoted 40 lines · Lorenzo Stoakes
Quoted 18 lines · Laurent Pinchart
Quoted 17 lines · Vlastimil Babka (SUSE)
Quoted 10 lines · Jori Koolstra

Ah, I still reigniting this discussion again :)

What about a combination of what David and Jeff say? The whole point seems to me that the salient information is not that an LLM was used (or are we going to tag Sashiko as well or any other LLM-based code review tool?), but what is was used to do. This information may be relevant for how the review is approached. The latter should perhaps only be in the cover letter and then we can drop the assisted-by tags altogether.

The question about enforcement remains.

It's not possible to enforce it. People can deny it if the tag is missing and you confront them and even though the submission has many signs of being obviously LLM, there is no definite proof. We've seen (likely, as there's no proof!) that happen in mm.

Quoted 7 lines
Quoted 1 line

Such situation then penalizes those who disclose so obviously they won't.

I think there's also a penality for those who don't disclose when they're told they should: it will lower trust. Kernel development is largely based on a trust model. If a contributor decides to adopt a deceiptful behaviour, they can expect maintainers to raise the bar for accepting patches, when not rejecting them outright.

Yes, I explicitly said this in response to somebody for whom there was overwhelming evidence they were submitting AI slop, and that they'd need to build it back up again.

It's precisely the issue as I see it.

But others within the community disagreed with me, so it turned into a very long and draining discussion that I don't particularly wish to repeat.

So we really need clarity on it being OK to do this (I remember saying this last year when I made an ultimately unsuccessful submission to the maintainer's summit about all this :)

Quoted 8 lines

What matters overall is being able to _quickly_ dismiss AI slop so that asymmetry between LLM generation + maintainer time isn't exploited.

And ultimately I think the trust model will end up being 'newcomes have 0, now build it up'.

Which sucks but this issue is simply existential for open source.

Has anybody tried throwing any of the obvious LLM slop submissions we have seen into one of these LLM detector things? To be clear, I've never tried those so I'm certainly no authority on if they even work reliably, but if so I wonder if something like that is a potential solution for elminating the worst cases..

Quoted 9 lines

I.e., suppose we had some Sashiko type LLM/bot whose job was mainly to detect purely LLM generated content based on some minimum level of confidence and reply with a loud and clear message to the thread. Maybe that would be a clear enough signal to maintainers and reviewers that something is not worth prioritizing for review.. Maybe also some "slop detected" feedback would help disincentivize flinging slop onto the lists. At the very least that could be something that is more easily configured/enabled per-subsystem without having to use per-subsystem commit tags.

Quoted 5 lines

Yup I thought of this, have done this on series and they do detect it reliably.

But then it becomes an arms race. People will get AI to try to defeat AI detection. So I'm not sure it's a safe road to go down.

That would be my concern too.

At this stage, I think it's better to make sure people know our expectations, and expect that the vast majority will understand it's a trust-based system where being caught willingly breaching trust will have a very high cost. Or have we reached a point where that doesn't work any more ?

Signature · 3 lines
Regards,

Laurent Pinchart
#44 lore raw
Quoted 11 lines · Laurent Pinchart
Quoted 2 lines · Lorenzo Stoakes

But then it becomes an arms race. People will get AI to try to defeat AI detection. So I'm not sure it's a safe road to go down.

That would be my concern too.

At this stage, I think it's better to make sure people know our expectations, and expect that the vast majority will understand it's a trust-based system where being caught willingly breaching trust will have a very high cost. Or have we reached a point where that doesn't work any more ?

Unfortunately there's a lot of people who have bad motives or feel there's prestige in kernel commits and are willing to cheat their way to it, or are pressured by their workplace, or etc. etc.

So I think this is far too idealistic. I've seen too much undisclosed AI being submitted and those people stridently denying they used it when it's brought up.

So I think tags are really useful to push back against those who are in good faith.

And for those who submit it dishonestly, I personally believe _reasonable_ and _strong_ evidence to believe it's generated should be enough to reject.

But there's not universal agreement on that, unfortunately, which makes it politically difficult.

I think honestly the only solution long-term will not even be to reject like this but rather we'll have to basically restrict newcomers to a very narrow band of submissions and have them build trust before they can send more.

Which really, really sucks but I don't see how we can keep the kernel alive any other way when the slop really ramps up.

Quoted 5 lines

--
Regards,

Laurent Pinchart

Thanks, Lorenzo

#45 lore raw
Quoted 30 lines

Op 02-07-2026 15:37 CEST schreef Lorenzo Stoakes <[email protected]>:

Quoted 11 lines · Laurent Pinchart
Quoted 2 lines · Lorenzo Stoakes

But then it becomes an arms race. People will get AI to try to defeat AI detection. So I'm not sure it's a safe road to go down.

That would be my concern too.

At this stage, I think it's better to make sure people know our expectations, and expect that the vast majority will understand it's a trust-based system where being caught willingly breaching trust will have a very high cost. Or have we reached a point where that doesn't work any more ?

Unfortunately there's a lot of people who have bad motives or feel there's prestige in kernel commits and are willing to cheat their way to it, or are pressured by their workplace, or etc. etc.

So I think this is far too idealistic. I've seen too much undisclosed AI being submitted and those people stridently denying they used it when it's brought up.

So I think tags are really useful to push back against those who are in good faith.

And for those who submit it dishonestly, I personally believe _reasonable_ and _strong_ evidence to believe it's generated should be enough to reject.

Quoted 7 lines

But there's not universal agreement on that, unfortunately, which makes it politically difficult.

I think honestly the only solution long-term will not even be to reject like this but rather we'll have to basically restrict newcomers to a very narrow band of submissions and have them build trust before they can send more.

It's total insanity to expect from maintainers to deal with huge, deep, changes in core subsystems by total unknown people, like you've had to deal with. What is the chance you happen to refuse a commit by an isolated genius that just happen to be able to do deep work without any kind of work leading up to that. And even then, if they are genuinely a genius, it very likely won't smell like AI slop.

Quoted 10 lines

Which really, really sucks but I don't see how we can keep the kernel alive any other way when the slop really ramps up.

Quoted 5 lines

--
Regards,

Laurent Pinchart

Thanks, Lorenzo

#46 lore raw
In reply to Lorenzo Stoakes
Quoted 67 lines · Lorenzo Stoakes
Quoted 56 lines · Brian Foster
Quoted 40 lines · Lorenzo Stoakes
Quoted 18 lines · Laurent Pinchart
Quoted 17 lines · Vlastimil Babka (SUSE)
Quoted 10 lines · Jori Koolstra

Ah, I still reigniting this discussion again :)

What about a combination of what David and Jeff say? The whole point seems to me that the salient information is not that an LLM was used (or are we going to tag Sashiko as well or any other LLM-based code review tool?), but what is was used to do. This information may be relevant for how the review is approached. The latter should perhaps only be in the cover letter and then we can drop the assisted-by tags altogether.

The question about enforcement remains.

It's not possible to enforce it. People can deny it if the tag is missing and you confront them and even though the submission has many signs of being obviously LLM, there is no definite proof. We've seen (likely, as there's no proof!) that happen in mm.

Quoted 7 lines
Quoted 1 line

Such situation then penalizes those who disclose so obviously they won't.

I think there's also a penality for those who don't disclose when they're told they should: it will lower trust. Kernel development is largely based on a trust model. If a contributor decides to adopt a deceiptful behaviour, they can expect maintainers to raise the bar for accepting patches, when not rejecting them outright.

Yes, I explicitly said this in response to somebody for whom there was overwhelming evidence they were submitting AI slop, and that they'd need to build it back up again.

It's precisely the issue as I see it.

But others within the community disagreed with me, so it turned into a very long and draining discussion that I don't particularly wish to repeat.

So we really need clarity on it being OK to do this (I remember saying this last year when I made an ultimately unsuccessful submission to the maintainer's summit about all this :)

Quoted 8 lines

What matters overall is being able to _quickly_ dismiss AI slop so that asymmetry between LLM generation + maintainer time isn't exploited.

And ultimately I think the trust model will end up being 'newcomes have 0, now build it up'.

Which sucks but this issue is simply existential for open source.

Has anybody tried throwing any of the obvious LLM slop submissions we have seen into one of these LLM detector things? To be clear, I've never tried those so I'm certainly no authority on if they even work reliably, but if so I wonder if something like that is a potential solution for elminating the worst cases..

Quoted 9 lines

I.e., suppose we had some Sashiko type LLM/bot whose job was mainly to detect purely LLM generated content based on some minimum level of confidence and reply with a loud and clear message to the thread. Maybe that would be a clear enough signal to maintainers and reviewers that something is not worth prioritizing for review.. Maybe also some "slop detected" feedback would help disincentivize flinging slop onto the lists. At the very least that could be something that is more easily configured/enabled per-subsystem without having to use per-subsystem commit tags.

Quoted 3 lines

Yup I thought of this, have done this on series and they do detect it reliably.

Interesting.

Quoted 3 lines

But then it becomes an arms race. People will get AI to try to defeat AI detection. So I'm not sure it's a safe road to go down.

Yeah that's fair, but my thinking is the goal would be more to detect slop content as opposed to just LLM usage. The trend of these discussions has been that we generally don't care too much about LLM use in general when it's used properly as a tool, but rather as you stated earlier we want to be able to quickly dismiss slop to avoid wasting maintainer and reviewer time.

It seems like we're generally able to sniff out pure LLM generated content in most cases. That suggests we should be able document some common patterns that tend to describe slop such that an LLM bot could detect and flag it. For example, "Slop bot has detected comments have LLM prose and just repeat what the code does," "Slop bot has detected unnecessary code volume and duplication," etc. etc.

So the idea with that would be that defeating the slop bot is the point. Consider it a sort of informal/minimal goal before a submitter is entitled to human review. But yeah, I guess it's still just a handwavy theory that you'd be able to reliably disentagle detection of general LLM code generation from something that more qualifies as LLM slop. Just thinking out loud.

Brian

Quoted 6 lines
Quoted 3 lines

Brian

Thanks, Lorenzo

#47 lore raw
Quoted 85 lines · Brian Foster
Quoted 67 lines · Lorenzo Stoakes
Quoted 56 lines · Brian Foster
Quoted 40 lines · Lorenzo Stoakes
Quoted 18 lines · Laurent Pinchart
Quoted 17 lines · Vlastimil Babka (SUSE)
Quoted 10 lines · Jori Koolstra

Ah, I still reigniting this discussion again :)

What about a combination of what David and Jeff say? The whole point seems to me that the salient information is not that an LLM was used (or are we going to tag Sashiko as well or any other LLM-based code review tool?), but what is was used to do. This information may be relevant for how the review is approached. The latter should perhaps only be in the cover letter and then we can drop the assisted-by tags altogether.

The question about enforcement remains.

It's not possible to enforce it. People can deny it if the tag is missing and you confront them and even though the submission has many signs of being obviously LLM, there is no definite proof. We've seen (likely, as there's no proof!) that happen in mm.

Quoted 7 lines
Quoted 1 line

Such situation then penalizes those who disclose so obviously they won't.

I think there's also a penality for those who don't disclose when they're told they should: it will lower trust. Kernel development is largely based on a trust model. If a contributor decides to adopt a deceiptful behaviour, they can expect maintainers to raise the bar for accepting patches, when not rejecting them outright.

Yes, I explicitly said this in response to somebody for whom there was overwhelming evidence they were submitting AI slop, and that they'd need to build it back up again.

It's precisely the issue as I see it.

But others within the community disagreed with me, so it turned into a very long and draining discussion that I don't particularly wish to repeat.

So we really need clarity on it being OK to do this (I remember saying this last year when I made an ultimately unsuccessful submission to the maintainer's summit about all this :)

Quoted 8 lines

What matters overall is being able to _quickly_ dismiss AI slop so that asymmetry between LLM generation + maintainer time isn't exploited.

And ultimately I think the trust model will end up being 'newcomes have 0, now build it up'.

Which sucks but this issue is simply existential for open source.

Has anybody tried throwing any of the obvious LLM slop submissions we have seen into one of these LLM detector things? To be clear, I've never tried those so I'm certainly no authority on if they even work reliably, but if so I wonder if something like that is a potential solution for elminating the worst cases..

Quoted 9 lines

I.e., suppose we had some Sashiko type LLM/bot whose job was mainly to detect purely LLM generated content based on some minimum level of confidence and reply with a loud and clear message to the thread. Maybe that would be a clear enough signal to maintainers and reviewers that something is not worth prioritizing for review.. Maybe also some "slop detected" feedback would help disincentivize flinging slop onto the lists. At the very least that could be something that is more easily configured/enabled per-subsystem without having to use per-subsystem commit tags.

Quoted 3 lines

Yup I thought of this, have done this on series and they do detect it reliably.

Interesting.

Quoted 3 lines

But then it becomes an arms race. People will get AI to try to defeat AI detection. So I'm not sure it's a safe road to go down.

Yeah that's fair, but my thinking is the goal would be more to detect slop content as opposed to just LLM usage. The trend of these discussions has been that we generally don't care too much about LLM use in general when it's used properly as a tool, but rather as you stated earlier we want to be able to quickly dismiss slop to avoid wasting maintainer and reviewer time.

Quoted 6 lines

It seems like we're generally able to sniff out pure LLM generated content in most cases. That suggests we should be able document some common patterns that tend to describe slop such that an LLM bot could detect and flag it. For example, "Slop bot has detected comments have LLM prose and just repeat what the code does," "Slop bot has detected unnecessary code volume and duplication," etc. etc.

Yep it might be helpful.

But it turns out this is more contentious than you might think, and it might be a hard sell.

Quoted 7 lines

So the idea with that would be that defeating the slop bot is the point. Consider it a sort of informal/minimal goal before a submitter is entitled to human review. But yeah, I guess it's still just a handwavy theory that you'd be able to reliably disentagle detection of general LLM code generation from something that more qualifies as LLM slop. Just thinking out loud.

Yeah tbh it'd not be perfect but I wouldn't mind if we did this.

Some information > no information.

Quoted 10 lines

Brian

Quoted 6 lines
Quoted 3 lines

Brian

Thanks, Lorenzo

Thanks, Lorenzo

#48 lore raw
In reply to Vlastimil Babka (SUSE)
Quoted 17 lines · Vlastimil Babka (SUSE)
Quoted 10 lines · Jori Koolstra

Ah, I still reigniting this discussion again :)

What about a combination of what David and Jeff say? The whole point seems to me that the salient information is not that an LLM was used (or are we going to tag Sashiko as well or any other LLM-based code review tool?), but what is was used to do. This information may be relevant for how the review is approached. The latter should perhaps only be in the cover letter and then we can drop the assisted-by tags altogether.

The question about enforcement remains.

It's not possible to enforce it. People can deny it if the tag is missing and you confront them and even though the submission has many signs of being obviously LLM, there is no definite proof. We've seen (likely, as there's no proof!) that happen in mm.

Quoted 5 lines

Such situation then penalizes those who disclose so obviously they won't. We should drop the tag and instead think how we can empower maintainers to be able to use their own judgment and deprioritize dealing with what they perceive as LLM slop, without fearing consequences of not being properly responsible etc, and not rely on any non-enforceable tags for that.

+1

I see no benefits of enforcing the tag for these exact reasons. Every LLM slop will miss the tag. OTOH, seeing reasonable contribution with the tag makes my spider-senses tingling and causing unnecessary prejudice. If the contribution is reasonable, how does the tag information helps me? I trust (or not) the person, regardless what tool they use.

And if we think about any future possible copyright issues with LLM contributions (like if there is ever a ruling that model trained on BSD data creates BSD-derivative work etc), does that tag anyhow solve it? Like if that ruling appear we will go through the history and revert the commits?

Best regards,
Krzysztof

#49 lore raw
Quoted 33 lines · Krzysztof Kozlowski
Quoted 17 lines · Vlastimil Babka (SUSE)
Quoted 10 lines · Jori Koolstra

Ah, I still reigniting this discussion again :)

What about a combination of what David and Jeff say? The whole point seems to me that the salient information is not that an LLM was used (or are we going to tag Sashiko as well or any other LLM-based code review tool?), but what is was used to do. This information may be relevant for how the review is approached. The latter should perhaps only be in the cover letter and then we can drop the assisted-by tags altogether.

The question about enforcement remains.

It's not possible to enforce it. People can deny it if the tag is missing and you confront them and even though the submission has many signs of being obviously LLM, there is no definite proof. We've seen (likely, as there's no proof!) that happen in mm.

Quoted 5 lines

Such situation then penalizes those who disclose so obviously they won't. We should drop the tag and instead think how we can empower maintainers to be able to use their own judgment and deprioritize dealing with what they perceive as LLM slop, without fearing consequences of not being properly responsible etc, and not rely on any non-enforceable tags for that.

+1

I see no benefits of enforcing the tag for these exact reasons. Every LLM slop will miss the tag. OTOH, seeing reasonable contribution with the tag makes my spider-senses tingling and causing unnecessary prejudice. If the contribution is reasonable, how does the tag information helps me? I trust (or not) the person, regardless what tool they use.

Quoted 5 lines

And if we think about any future possible copyright issues with LLM contributions (like if there is ever a ruling that model trained on BSD data creates BSD-derivative work etc), does that tag anyhow solve it? Like if that ruling appear we will go through the history and revert the commits?

Why would you take information _away_ from maintainers?

You're making every LLM 'accusation' a risk for a maintainer because you might get the 'how dare you accuse me of using an LLM rah rah rah' response.

Why not eliminate that in at least some cases?

I continue to be baffled at people's opposition adding a single line to emails, or a single little comment on the end of it.

I do agree with Vlasta that we need to have a clearer way to just say no (TM) if we strongly suspect an LLM.

I had a very unpleasant experience dealing with blowback for doing that in a _very_ blatant case and I'd rather not repeat it if it's at all possible.

Quoted 3 lines

Best regards,
Krzysztof

Thanks, Lorenzo

#50 lore raw
Quoted 40 lines · Lorenzo Stoakes
Quoted 33 lines · Krzysztof Kozlowski
Quoted 17 lines · Vlastimil Babka (SUSE)
Quoted 10 lines · Jori Koolstra

Ah, I still reigniting this discussion again :)

What about a combination of what David and Jeff say? The whole point seems to me that the salient information is not that an LLM was used (or are we going to tag Sashiko as well or any other LLM-based code review tool?), but what is was used to do. This information may be relevant for how the review is approached. The latter should perhaps only be in the cover letter and then we can drop the assisted-by tags altogether.

The question about enforcement remains.

It's not possible to enforce it. People can deny it if the tag is missing and you confront them and even though the submission has many signs of being obviously LLM, there is no definite proof. We've seen (likely, as there's no proof!) that happen in mm.

Quoted 5 lines

Such situation then penalizes those who disclose so obviously they won't. We should drop the tag and instead think how we can empower maintainers to be able to use their own judgment and deprioritize dealing with what they perceive as LLM slop, without fearing consequences of not being properly responsible etc, and not rely on any non-enforceable tags for that.

+1

I see no benefits of enforcing the tag for these exact reasons. Every LLM slop will miss the tag. OTOH, seeing reasonable contribution with the tag makes my spider-senses tingling and causing unnecessary prejudice. If the contribution is reasonable, how does the tag information helps me? I trust (or not) the person, regardless what tool they use.

Quoted 5 lines

And if we think about any future possible copyright issues with LLM contributions (like if there is ever a ruling that model trained on BSD data creates BSD-derivative work etc), does that tag anyhow solve it? Like if that ruling appear we will go through the history and revert the commits?

Quoted 6 lines

Why would you take information _away_ from maintainers?

You're making every LLM 'accusation' a risk for a maintainer because you might get the 'how dare you accuse me of using an LLM rah rah rah' response.

Why not eliminate that in at least some cases?

Because I don't think we will be able to enforce that information, therefore it is close to pointless.

And if you ask about future copyright issues, I simply do not believe the tags will matter based on argument (repeating): what are you going to do with that information that commit was involving LLM tool which now received some copyright-related verdict?

Quoted 6 lines

I continue to be baffled at people's opposition adding a single line to emails, or a single little comment on the end of it.

I do agree with Vlasta that we need to have a clearer way to just say no (TM) if we strongly suspect an LLM.

This part is not being discussed by me and I think the thread itself is not about it.

Quoted 3 lines

I had a very unpleasant experience dealing with blowback for doing that in a _very_ blatant case and I'd rather not repeat it if it's at all possible.

Well, I made here the point already - that blatant blowback and any future similar slop will not use any tags, thus the tags do not solve that problem.

Basically having the tag solves no problems we experience. The tags are worthless in problem solving...

Best regards,
Krzysztof

#51 lore raw
Quoted 43 lines · Krzysztof Kozlowski
Quoted 42 lines · Lorenzo Stoakes
Quoted 33 lines · Krzysztof Kozlowski
Quoted 17 lines · Vlastimil Babka (SUSE)
Quoted 10 lines · Jori Koolstra

Ah, I still reigniting this discussion again :)

What about a combination of what David and Jeff say? The whole point seems to me that the salient information is not that an LLM was used (or are we going to tag Sashiko as well or any other LLM-based code review tool?), but what is was used to do. This information may be relevant for how the review is approached. The latter should perhaps only be in the cover letter and then we can drop the assisted-by tags altogether.

The question about enforcement remains.

It's not possible to enforce it. People can deny it if the tag is missing and you confront them and even though the submission has many signs of being obviously LLM, there is no definite proof. We've seen (likely, as there's no proof!) that happen in mm.

Quoted 5 lines

Such situation then penalizes those who disclose so obviously they won't. We should drop the tag and instead think how we can empower maintainers to be able to use their own judgment and deprioritize dealing with what they perceive as LLM slop, without fearing consequences of not being properly responsible etc, and not rely on any non-enforceable tags for that.

+1

I see no benefits of enforcing the tag for these exact reasons. Every LLM slop will miss the tag. OTOH, seeing reasonable contribution with the tag makes my spider-senses tingling and causing unnecessary prejudice. If the contribution is reasonable, how does the tag information helps me? I trust (or not) the person, regardless what tool they use.

Quoted 5 lines

And if we think about any future possible copyright issues with LLM contributions (like if there is ever a ruling that model trained on BSD data creates BSD-derivative work etc), does that tag anyhow solve it? Like if that ruling appear we will go through the history and revert the commits?

Why would you take information _away_ from maintainers?

Quoted 7 lines
Quoted 4 lines

You're making every LLM 'accusation' a risk for a maintainer because you might get the 'how dare you accuse me of using an LLM rah rah rah' response.

Why not eliminate that in at least some cases?

Because I don't think we will be able to enforce that information, therefore it is close to pointless.

'We can't have complete data so let's have no data'

Not sure that's convincing, sorry.

Quoted 5 lines

And if you ask about future copyright issues, I simply do not believe the tags will matter based on argument (repeating): what are you going to do with that information that commit was involving LLM tool which now received some copyright-related verdict?

And if undisclosed, but detectable by LLM checks or otherwise evidenced...? Not sure you can argue 'no point in tags because people don't use them' but also 'copyright issues only with tags'.

Anyway I think this is likely to be a non-issue given global regulatory trends on this stuff.

Quoted 10 lines
Quoted 7 lines

I continue to be baffled at people's opposition adding a single line to emails, or a single little comment on the end of it.

I do agree with Vlasta that we need to have a clearer way to just say no (TM) if we strongly suspect an LLM.

This part is not being discussed by me and I think the thread itself is not about it.

Well ok on your part, but I think it's clearly part of it, quoting Vlasta:

"instead think how we can empower maintainers to be able to use their own judgment and deprioritize dealing with what they perceive as LLM slop, without fearing consequences of not being properly responsible etc, and not rely on any non-enforceable tags for that."

Quoted 11 lines
Quoted 4 lines

I had a very unpleasant experience dealing with blowback for doing that in a _very_ blatant case and I'd rather not repeat it if it's at all possible.

Well, I made here the point already - that blatant blowback and any future similar slop will not use any tags, thus the tags do not solve that problem.

Basically having the tag solves no problems we experience. The tags are worthless in problem solving...

Well in my actual experience of doing review I am finding them useful as a low-cost way of being able to bring up LLMs.

Some information > no information.

And requiring disclosure makes not disclosing an easier sell. If we drop it then people will take that as carte blanche to do whatever.

Quoted 3 lines

Best regards,
Krzysztof

Thanks, Lorenzo

#52 lore raw
In reply to Krzysztof Kozlowski
Quoted 24 lines · Krzysztof Kozlowski
Quoted 17 lines · Vlastimil Babka (SUSE)
Quoted 10 lines · Jori Koolstra

Ah, I still reigniting this discussion again :)

What about a combination of what David and Jeff say? The whole point seems to me that the salient information is not that an LLM was used (or are we going to tag Sashiko as well or any other LLM-based code review tool?), but what is was used to do. This information may be relevant for how the review is approached. The latter should perhaps only be in the cover letter and then we can drop the assisted-by tags altogether.

The question about enforcement remains.

It's not possible to enforce it. People can deny it if the tag is missing and you confront them and even though the submission has many signs of being obviously LLM, there is no definite proof. We've seen (likely, as there's no proof!) that happen in mm.

Quoted 5 lines

Such situation then penalizes those who disclose so obviously they won't. We should drop the tag and instead think how we can empower maintainers to be able to use their own judgment and deprioritize dealing with what they perceive as LLM slop, without fearing consequences of not being properly responsible etc, and not rely on any non-enforceable tags for that.

Quoted 6 lines

+1

I see no benefits of enforcing the tag for these exact reasons. Every LLM slop will miss the tag. OTOH, seeing reasonable contribution with the tag makes my spider-senses tingling and causing unnecessary prejudice.

I'm not even sure the prejudice is unnecessary, given how studies point to the cognitive decline impact of generative AI usage.

I have previously heard long-term, experienced developers saying they handle review feedback by "doing whatever the reviewer asks" without "really trying to understand" in order to get their code merged. That doesn't lead to very good long term results. When such developers turn to LLMs to write code, I'm pretty sure the prejudice is warranted.

Quoted 9 lines

If the contribution is reasonable, how does the tag information helps me? I trust (or not) the person, regardless what tool they use.

And if we think about any future possible copyright issues with LLM contributions (like if there is ever a ruling that model trained on BSD data creates BSD-derivative work etc), does that tag anyhow solve it? Like if that ruling appear we will go through the history and revert the commits?

Signature · 3 lines
Regards,

Laurent Pinchart
#53 lore raw
In reply to Christian Brauner
Quoted 22 lines · Christian Brauner

I remain very confused by our coding assistant contribution guidelines. I'm going to be a bit polemic now but this seriously in good faith.

Why precisely do we require all this detailed information about what specific coding assistant was used?

I find it very irritating that our git history has effectively started to function a bit like a free advertising platform for a bunch of AI companies and their proprietary agents and models.

And it reamins unclear to me what exactly we do get out of this detailed
information: Do we want to run statistical analysis on what agent and model is used the most and publish that on LWN at some point?

I acknowledge that my stance is even more radical: imho we would just stop it with any disclosure requirements completely. It's useless imho. We already see that other than core contributors most people don't care and will just not disclose their usage of AI. I think this is entirely pointless and worse it brings in undefined legal status as well. It's not like recent events of pulling certain models from the face of the earth have made this any less concerning.

Quoted 4 lines

But fine, if we want to do this can we please just dumb it down to

Assisted-by LLM

Yes, I agree. Useful information would be the model or trained data, e.g. to judge for any copyright issues, but I doubt anyone will ever provide such details.

I also see little value to keep even the Assisted-by tag in the first place. I am interested in seeing named respectable tools in commit msg as reasons for doing this commit, e.g. I am fixing warning from Smatch so I mention Smatch. Sashiko fits this purpose as well. I have no interests to see "Claude" as reason of doing something.

Best regards,
Krzysztof

#54 lore raw
In reply to Christian Brauner
Quoted 5 lines · Christian Brauner
Assisted-by LLM

or

Assisted-by Coding Assistant

I think what is more relevant is what assistance there was. If the code was generated by an LLM we should plain out reject it out of copyright grounds. If it was used for validation or ideas: who care?

I.e. do we need this at all except as a guard against vibe code junk that pull in other copyrighted material? And do we really rely on a tag instead of detecting it by the usual signs?

#55 lore raw
Quoted 7 lines · Christoph Hellwig
Quoted 5 lines · Christian Brauner
Assisted-by LLM

or

Assisted-by Coding Assistant
Quoted 8 lines

I think what is more relevant is what assistance there was. If the code was generated by an LLM we should plain out reject it out of copyright grounds. If it was used for validation or ideas: who care?

I.e. do we need this at all except as a guard against vibe code junk that pull in other copyrighted material? And do we really rely on a tag instead of detecting it by the usual signs?

I don't think this work at all as a guard for vibe code junk. My experience recently is receiving broken patches clearly LLM generated without no tag at all.
Some functional patches clearly generated by LLM without tags where I need to go to the developer and tell to add the proper tags. And yet some patches that seem functional but broken details buried in 200 line commit descriptions that we've all need to spend time reading.

I'd vote for dropping the tags too, they have been for me at least just a burden trying to identify if whoever wrote a patch used a LLM to generate it and didn't add the tag.

I think it was a nice try but didn't prove to be useful at the end (at least not for me).

Cheers.

#56 lore raw
In reply to Christian Brauner
Quoted 10 lines · Christian Brauner

I remain very confused by our coding assistant contribution guidelines. I'm going to be a bit polemic now but this seriously in good faith.

Why precisely do we require all this detailed information about what specific coding assistant was used?

I find it very irritating that our git history has effectively started to function a bit like a free advertising platform for a bunch of AI companies and their proprietary agents and models.

Quoted 6 lines

And it reamins unclear to me what exactly we do get out of this detailed
information: Do we want to run statistical analysis on what agent and model is used the most and publish that on LWN at some point?

I acknowledge that my stance is even more radical: imho we would just stop it with any disclosure requirements completely.

Sorry to drop in as a relatively uninformed person, but it seems like the following mails would be relevant for that discussion:

https://lore.kernel.org/lkml/[email protected]/T/

If LLM code were no longer committed to the kernel, which wouldn't exclude using an LLM to pinpoint problem spots and security bugs as long as it's not used to produce the fix itself, then the commits also would no longer need an attribution.

Regards,

Ellie

#57 lore raw
Quoted 15 lines · Ellie
Quoted 14 lines · Christian Brauner

I remain very confused by our coding assistant contribution guidelines. I'm going to be a bit polemic now but this seriously in good faith.

Why precisely do we require all this detailed information about what specific coding assistant was used?

I find it very irritating that our git history has effectively started to function a bit like a free advertising platform for a bunch of AI companies and their proprietary agents and models.

And it reamins unclear to me what exactly we do get out of this detailed
information: Do we want to run statistical analysis on what agent and model is used the most and publish that on LWN at some point?

Quoted 7 lines
Quoted 2 lines

I acknowledge that my stance is even more radical: imho we would just stop it with any disclosure requirements completely.

Sorry to drop in as a relatively uninformed person, but it seems like the following mails would be relevant for that discussion:

https://lore.kernel.org/lkml/[email protected]/T/

Your messages got completely ignored for a month and a half. Most developers (including myself) don't read LKML due to the high traffic, but I'm still surprised by the complete lack of reply. Maybe CC'ing the [email protected] mailing list would have helped ?

Quoted 4 lines

If LLM code were no longer committed to the kernel, which wouldn't exclude using an LLM to pinpoint problem spots and security bugs as long as it's not used to produce the fix itself, then the commits also would no longer need an attribution.

That's absolutely right, and I would welcome that outcome. At this point I don't think I'm talking for the majority though :-)

Signature · 3 lines
Regards,

Laurent Pinchart
#58 lore raw

Re: [PATCH RFC] coding-assistants: simplify attribution - WIPO recommendations also seem kind of worrying

Quoted 4 lines · Laurent Pinchart

Your messages got completely ignored for a month and a half. Most developers (including myself) don't read LKML due to the high traffic, but I'm still surprised by the complete lack of reply. Maybe CC'ing the [email protected] mailing list would have helped ?

Given the ongoing discussion I'm kind of wondering if it has been noticed by now, I apologize if it has and I just missed it.

Sadly, my concerning finds keep piling up, e.g. here's the WIPO, World Intellectual Property Organization, on what they recommend for AI:

https://www.wipo.int/publications/en/details.jsp?id=4713

Quote: "Consider using generative AI tools that have trained solely on licensed, public domain, or a user's own training data. [...] Thoroughly vet datasets when training or fine-tuning generative AI. Verify IP ownership, license coverage for AI training, [...]"

I'm not a lawyer, so I could be wrong and this isn't legal advice:

But it seems to me like neither do the Linux Foundations guidelines seem to be aware of this or adhere to this, nor does there seem to be a single coding LLM available anywhere that fulfills these.

(Since wouldn't that require training data that is both GPL-relicensing compatible and also doesn't require attribution? The latter I've never seen with any coding LLM out there.)

I wonder if the Linux Foundation would find it interesting what the WIPO says here, given how important the kernel is?

The angle of it just being a tool doesn't fully seem aware of such concerns. At least when actual LLM code is added into the kernel.

(And at the same time, it's probably possible to make such a vetted LLM if anybody wanted to. But that might require policies that enforce it.)

Regards,

Ellie

A message that is not in the archive (sent off-list or not yet received): [email protected]

#60 lore raw

Hi,
I agree that providing an advertizing platform for LLM/LAM/MCP/A2A providers should be avoided.
Detailed information could still be provided in announcements or the mailing list if others might be interested.
There will be public discussions about who used/likes/prefers whatever model/tool for whatever task anyway.

With the patch itself, maybe it might be important to know how AI has been used/helped to create it. Copy+paste code from AI / getting code from AI but verify,rework,adjust manually / getting the basic idea or how to overcome issues, but coding done by humans / comments provided by AI ...

This dicussion might be the easiest part imagining the future.
What if the patch/feature would actually make use of MCP/A2A - that's a different story. Local guardrails need to be guaranteed, remote ones requested from the endpoint, eventually dropped if not satisfied like in a failed TLS handshake.

Just my 2c,
Christian

Reviewed-by on v1 1/1
#61 lore raw
In reply to Christian Brauner
Quoted 28 lines · Christian Brauner

I remain very confused by our coding assistant contribution guidelines. I'm going to be a bit polemic now but this seriously in good faith.

Why precisely do we require all this detailed information about what specific coding assistant was used?

I find it very irritating that our git history has effectively started to function a bit like a free advertising platform for a bunch of AI companies and their proprietary agents and models.

And it reamins unclear to me what exactly we do get out of this detailed
information: Do we want to run statistical analysis on what agent and model is used the most and publish that on LWN at some point?

I acknowledge that my stance is even more radical: imho we would just stop it with any disclosure requirements completely. It's useless imho. We already see that other than core contributors most people don't care and will just not disclose their usage of AI. I think this is entirely pointless and worse it brings in undefined legal status as well. It's not like recent events of pulling certain models from the face of the earth have made this any less concerning.

But fine, if we want to do this can we please just dumb it down to

Assisted-by LLM

or

Quoted 7 lines
Assisted-by Coding Assistant

or something else. That still gives the "careful review" signal to reviewers that want to pay special attention to LLM generated work while avoiding this slew of metadata.

FWIW I'm fine with this. We can always send the comment stuff as a follow up. So:

Maybe send it non-RFC with a cleaned up commit msg? Feel free to add my tag to that.

Quoted 30 lines
---
 Documentation/process/coding-assistants.rst | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)
Documentation/process/coding-assistants.rst +2 -7
index 899f4459c52d..fe34f3e7e828 100644
@@ -43,12 +43,8 @@ When AI tools contribute to kernel development, proper attribution
 helps track the evolving role of AI in the development process.
 Contributions should include an Assisted-by tag in the following format::
 
-  Assisted-by: AGENT_NAME:MODEL_VERSION [TOOL1] [TOOL2]
+  Assisted-by: LLM [TOOL1] [TOOL2]
 
-Where:
-
-* ``AGENT_NAME`` is the name of the AI tool or framework
-* ``MODEL_VERSION`` is the specific model version used
 * ``[TOOL1] [TOOL2]`` are optional specialized analysis tools used
   (e.g., coccinelle, sparse, smatch, clang-tidy)
 
@@ -56,4 +52,4 @@ Basic development tools (git, gcc, make, editors) should not be listed.
 
 Example::
 
-  Assisted-by: Claude:claude-3-opus coccinelle sparse
+  Assisted-by: LLM coccinelle sparse
 
---
Quoted 3 lines

base-commit: dc59e4fea9d83f03bad6bddf3fa2e52491777482
change-id: 20260701-work-coding-assistants-650ae1202ee0

Cheers, Lorenzo