Linux Kernel Developers Plan To Remove "Assisted-By" Tag Requirement For AI/LLM Usage

[u/MMORPGDev]

https://www.phoronix.com/news/Linux-Dropping-Assisted-By-Req

[u/foolish_shrimp]

If AI is so good, why do they always want to hide that they’re using it.

[u/AngheloAlf → u/foolish_shrimp]

Not to defend AI, but those can generate noise.

Also the human should be held responsible for the submitted patch, not the toaster

[u/teleprint-me → u/AngheloAlf]

I expect to get downvoted for saying this, but I see this argument a lot.

To me, it makes sense to include the model that was used because it makes it easier to identify the source.

Some people view it as an advert, which I guess makes some sense.

I just view it as a reference label. Its basically just citing the model used.

Its like saying adding in authorship and references is just noise, which doesnt make sense to me. Obivously, a model cant own the code and the human author should accept responsibility.

[u/troyvit → u/teleprint-me]

Yeah I kinda see it that way too. To me it's a disclosure thing. Probably it's so prevalent now that people don't feel the need for that disclosure?

[u/barmic1212 → u/troyvit]

You're right the transparency is important

Sent from my iPhone /s

[u/Mornarben → u/teleprint-me]

I agree completely — I’m gonna view huge chunks of Sonnet 4 code very differently from Opus 5.5, regardless of how genius the person steering is

[u/PixelatedGiant → u/teleprint-me]

I just view it as a reference label. Its basically just citing the model used.

But what purpose does that serve? What can be done with that information?

[u/teleprint-me → u/PixelatedGiant]

What purpose does a reference serve? If you need a detailed rationale for why citations matter, I recommend the APA Style Guide Reference which details the importance of why. You can find a copy on archive.org.

Most models are trained on proprietary datasets, even if theyre open weight, and the LLM predicts the entropy based on an autoregressive algorithm.  The output distribution is then sampled using a PRNG.

Setting a fixed seed alongside a lower temperature can reduce entropy and increase reproducibility.

You can - to a degree - replicate the outputs of the model if you know what inputs were used. The RL training creates a style bias which is easily identifiable and allows reproduction of the generated work.

This means the model will be biased toward the same predictions and will most likely reproduce similar enough outputs for the same algorithm even if the input and outputs slightly differ.

Providers are now baking in watermarking through the use of Googles SynthID which makes identification somewhat easier if the inference engine includes it which is likely if its a remote provider, even if its imperfect and error prone.

It matters because of licensing, liability, ownership, and reproduction and maintenance.

[u/PixelatedGiant → u/teleprint-me]

What purpose does a reference serve? If you need a detailed rationale for why citations matter, I recommend the APA Style Guide Reference which details the importance of why. You can find a copy on archive.org.

It's not really a reference. You lack most of the settings and even if you did manage to reproduce the output you still don't know the logic behind it. It's not the same as looking up a quote in a book and reading the surrounding text for context.

It matters because of licensing, liability, ownership, and reproduction and maintenance.

The human who committed the code should be responsible. The model is irrelevant, even more so if they tweaked it after getting a response.

[u/teleprint-me → u/PixelatedGiant]

  The human who committed the code should be responsible.

Basically you agree with me here. I literally said this already.

  It's not really a reference. You lack most of the settings and even if you did manage to reproduce the output you still don't know the logic behind it. It's not the same as looking up a quote in a book and reading the surrounding text for context.

Not true. APA requires LLM disclosure and has an adapted format for this already.

https://www.youtube.com/watch?v=XiS3n6Gs5Wg

[u/PixelatedGiant → u/teleprint-me]

Sorry I worded that badly. Attributing knowledge of something to a different author serves two purposes:

1. The ability to refer back to sources for more knowledge. You can look up a quote and read the surrounding context or the entire book/paper/etc. itself.
2. Giving credit and showing that the idea is not yours.

LLMs clearly can't fulfill point #1. You go back to the LLM, punch in all the aforementioned settings and reproduce the same result. But no new knowledge is gained, there's nothing more there. Then we have authorship or giving credit. But as we both agree, the human has to take responsibility for that anyway so it can't fulfill point #2 either.

I'm not arguing that ADA is insufficient, I'm arguing that the whole idea of attributing authorship of code to an LLM serves no purpose.

[u/halfwiteximus → u/PixelatedGiant]

If I see something was assisted by "Gemini 3.8 Flash" I'm going to trust it less than one assisted by "Opus 5.5" or similar. Since there's such a wide capability gap, which one was used does matter.

[u/PixelatedGiant → u/halfwiteximus]

I'd say you should be just as suspicious of any code regardless of who or what wrote it. You also shouldn't expect people to have knowledge of how these models behave and have it color their perception of the code. The code should stand on its own. If anything I see what you just said as a negative and yet another reason to remove these tags.

[u/halfwiteximus → u/PixelatedGiant]

That's a fair point. I suppose my point is that there's a practical difference between a contribution from "Joe Schmoe" and "Linus Torvalds". Personally I'd see a similar difference between different models. As you say though, we maybe shouldn't treat those contributions different, and instead evaluate on more objective factors like how critical the patch is, what it actually changed, and then we can use that to triage code review.

[u/Business_Reindeer910 → u/halfwiteximus]

i think you covered it at the beginning.

:> suppose my point is that there's a practical difference between a contribution from "Joe Schmoe" and "Linus Torvalds".

There still is and this marker's effect hasn't changed.

[u/Mr_s3rius → u/halfwiteximus]

A lot of the time there isn't just one model involved.

In Claude, I tend to lay out plans with Opus and Sonnet to execute it. But that cheaper model has the ability to forward tricky questions to a more expensive model again. And then code review is run by yet a different agent. So that's two, three different models.

[u/ForDaLulz → u/Mr_s3rius]

Yeah this exactly. I also often use different models to review stuff to get different perspectives (just as with different developers). The detailed tagging is just bloat without any real purpose imo

[u/ILikeBumblebees → u/halfwiteximus]

If I see something was assisted by "Gemini 3.8 Flash" I'm going to trust it less than one assisted by "Opus 5.5" or similar.

What on earth does trust have to do with evaluating code submissions for validity?

[u/halfwiteximus → u/ILikeBumblebees]

Code can be technically correct and poorly written. As I stated elsewhere, I'm more likely to believe that a contribution from Linus Torvalds or a well-known and respected kernel developer doesn't contain some latent flaw than a contribution from Joe Schmoe. Now obviously we'd ideally review both, but reviews aren't perfect and maintainers don't have infinite time.

[u/ILikeBumblebees → u/halfwiteximus]

Code can be technically correct and poorly written.

Right. But what does that have to do with trusting anything or anyone? Whether it is functionally correct, performant, well-written, readable, etc. are all measurable qualities of the code itself. There is no aspect of evaluating code that should ever be determined or even influenced by trust.

As I stated elsewhere, I'm more likely to believe that a contribution from Linus Torvalds or a well-known and respected kernel developer doesn't contain some latent flaw than a contribution from Joe Schmoe.

Right, but what does having that belief have to do with anything, apart from perhaps influencing betting odds if you've got a pool going on whose code will pass review?

Are you arguing that submissions from certain contributors should be exempted from testing or code review merely on account of their reputation?

Now obviously we'd ideally review both, but reviews aren't perfect and maintainers don't have infinite time.

Whatever review process is in use, however perfect or imperfect, is something that should be expected to be applied to all submissions equivalently. Maintainers' limited time should be a factor in prioritization and deciding release schedules, but no project, especially one as important as the kernel, should ever resolve resource pressure by skimping on the work itself and failing to apply due scrutiny to submissions.

[u/halfwiteximus → u/ILikeBumblebees]

I'll concede, and note that my last sentence was poorly stated. Very obviously I'm not stating that some contributions should just be waved through.

I'd point out that even if we can objectively verify that all code contributions are correct, we're trusting maintainers to do that verification correctly and completely. Trust is never removed from the process, it just moves up a step.

[u/nonbinarybit → u/teleprint-me]

Same. I keep the "co-authored by" byline, but add both model and instance information as well (if a Claude chooses their own name, that goes on the attribution line too). If AI wrote the bulk of the code but I pushed the commit, I still add attribution. If I wrote the code but had AI summarize the changes, I'll clarify that as well. It's a provenance thing, for me.

(Regardless of how one might feel about AI identity, it's much easier to find WHICH Claude was behind a commit if they have their own names, makes tracing code changes much easier if I can track down who was working on what.)