16 ms·

AI assistance when contributing to the Linux kernel

• bitwize 7mo ago
  Good. The BSDs should follow suit. It is unreasonable to expect any developer not to use AI in 2026.
  • vips7L 7mo ago
    It’s perfectly reasonable. We’ve been doing it for decades. It’s completely unreasonable to expect every developer to use “ai”, especially when it comes at such a heavy monetary cost.
• baggy_trough 7mo ago
  Sounds sensible.
• ipython 7mo ago
  Glad to see the common-sense rule that only humans can be held accountable for code generated by AI agents.
  • pixel_popping 7mo ago
    [flagged]
    • daveguy 7mo ago
      Not insane at all. Just a very useful shortcut. Not everyone wants to move fast and break shit.
      • pixel_popping 7mo ago
        I still think it's insane, why would you care about the "origin" of the code as long as there is a human accountable (that you can ban anyway)?
        • 59nadir 7mo ago
          Because you don't want to deal with people who can't write their own code. If they can, the rule will do nothing to stop them from contributing. It'll only matter if they simply couldn't make their contribution without LLMs.
          • pixel_popping 7mo ago
            So tomorrow, if a model genuinely find a bunch of real vulnerabilities, you just would ignore them? that makes no sense.
            • 59nadir 7mo ago
              An LLM finding problems in code is not the same at all as someone using it to contribute code they couldn't write or haven't written themselves to a project. A report stating "There is a bug/security issue here" is not itself something I have to maintain, it's something I can react to and write code to fix, then I have to maintain that code.
              • seba_dos1 7mo ago
                Well, until you start getting dozens of generated reports that you take your time to review just to find out that they're all plausible-looking bullshit about non-issues. We already had that happening with other kinds of automated tooling, but at least it used to be easier to detect by quick skimming.
        • streetfighter64 7mo ago
          If your doctor told you he used an ouija board to find your diagnosis, would you care about the origin of the diagnosis or just trust that he'll be accountable for it?
          • pixel_popping 7mo ago
            If the Ouija board was powered by Opus, who knows :D
    • pydry 7mo ago
      And yet it puts a stop to the tsunami of slop and it's pretty much impossible to prove anything of value was lost.
      • pixel_popping 7mo ago
        but why? it's a human making the PR and you can shame/ban that human anyway.
        • yoyohello13 7mo ago
          > it's a human making the PR Is it? Remember when that agent wrote a hit piece about the maintainer because he wouldn't merge it's PR?
          • pixel_popping 7mo ago
            That's a different issue actually.
        • podgietaru 7mo ago
          Volume - things take time to review. If you’re inundated with so many PRs then it’s harder to curate in general
        • Ekaros 7mo ago
          You are treating humans as reasonable actors. They very often are not. On easy to access platforms like github you can have humans just working as intermediaries between LLM and the github. Not actually checking or understanding what they put in a pull request. Banning these people outright with clear rules is much faster and easier than trying to argue with them. Linux is somewhat harder to contribute to and they already have sufficient barriers in place so they can rely on more reasonable human actors.
        • materielle 7mo ago
          I think AI bans are more common in projects where the maintainers are nice people that thoughtfully want to consider each PR and provide a reasoned response if rejected. That’s only feasible when the people who open PRs are acting in good faith, and control both the quality and volume of PRs to something that the maintainers can realistically (and ought to) review in their 2-3 hours of weekly free time. Linux is a bit different. Your code can be rejected, or not even looked at in the first place, if it’s not a high quality and desired contribution. Also, it’s not just about PR quality, but also volume. It’s possible for contributions to be a net benefit in isolation. But most open source maintainers only have an hour or so a week to review PRs and need to prioritize aggressively. People who code with AI agents would benefit themselves to ask “does this PR align with the priorities and time availability of the maintainer?” For instance, I’m sure we could point AI at many open source projects and tell it to optimize performance. And the agent would produce a bunch of high quality PRs that are a good idea in isolation. But what if performance optimization isn’t a good use of time for a given maintainer’s weekly code review quota? Sure, maintainers can simply close the PR without a reason if they don’t have time. But I fear we are taking advantage of nice people, who want to give a reasoned response to every contribution, but simply can’t keep up with the volume that agents can produce.
    • tom_ 7mo ago
      It is no more insane than doing the opposite. This whole business has yet to play itself out.
    • KoftaBob 7mo ago
      It's just a form of sanctimonious virtue-signaling that's trendy right now.
    • CivBase 7mo ago
      In most cases I've seen it's because they get overwhelmed by sloppy contributions from developers who do not bother to review their AI's output. Code reviews are a lot of work.
      • Gigachad 7mo ago
        Also “responsibility” and “accountability” mean little for anon contributors from the internet. You can ban them but a thousand more will still be spamming you with slop.
• qsort 7mo ago
  Basically the rules are that you can use AI, but you take full responsibility for your commits and code must satisfy the license. That's... refreshingly normal? Surely something most people acting in good faith can get behind.
  • galaxyLogic 7mo ago
    But then if AI output is not under GNU General Public License, how can it become so just because a Linux-developer adds it to the code-base?
    • afro88 7mo ago
      Same as if a regular person did the same. They are responsible for it. If you're using AI, check the code doesn't violate licenses
      • sarchertech 7mo ago
        How could you do that though? You can’t guarantee that there aren’t chunks of copied code that infringes.
        • shevy-java 7mo ago
          But the responsible party is still the human who added the code. Not the tool that helped do so.
          • sarchertech 7mo ago
            In a court case the responsibility party very well could be the Linux foundation because this is a foreseeable consequence of allowing AI contributions. There’s no reasonable way for a human to make such a guarantee while using AI generated code.
            • Chance-Device 7mo ago
• dataviz1000 7mo ago
  This is discussed in the Linus vs Linus interview, "Building the PERFECT Linux PC with Linus Torvalds". [0] [0] https://youtu.be/mfv0V1SxbNA?si=CBnnesr4nCJLuB9D&t=2003 https://youtu.be/mfv0V1SxbNA?si=CBnnesr4nCJLuB9D&t=2003
  • globular-toast 7mo ago
    Hardly "discussed", perhaps "mentioned". Sebastian is basically an entertainer who can plug things in to sockets.
• newsoftheday 7mo ago
  > All code must be compatible with GPL-2.0-only How can you guarantee that will happen when AI has been trained a world full of multiple licenses and even closed source material without permission of the copyright owners...I confirmed that with several AI's just now.
  • tmp10423288442 7mo ago
    Wait for court cases I suppose - not really Linus Torvalds' job to guess how they'll rule on the copyright of mere training. Presumably having your AI actually consult codebases with incompatible licenses at runtime is more risky.
  • philipov 7mo ago
    You take responsibility. That means if the AI messes up, you get punished. No pushing blame onto the stupid computer. If you're not comfortable with that, don't use the AI.
    • sarchertech 7mo ago
      There’s no reasonable way for you to use AI generated code and guarantee it doesn’t infringe. The whole use it but if it behaves as expected, it’s your fault is a ridiculous stance.
      • philipov 7mo ago
        If you think it's an unacceptable risk to use a tool you can't trust when your own head is on the line, you're right, and you shouldn't use it. You don't have to guarantee anything. You just have to accept punishment.
        • sarchertech 7mo ago
          That’s just it though it’s not just your head. The liability could very likely also fall on the Linux foundation. You can’t say “you can do this thing that we know will cause problems that you have no way to mitigate, but if it does we’re not liable”. The infringement was a foreseeable consequence of the policy.
• dec0dedab0de 7mo ago
  All code must be compatible with GPL-2.0-only Am I being too pedantic if I point out that it is quite possible for code to be compatible with GPL-2.0 and other licenses at the same time? Or is this a term that is well understood?
  • philipov 7mo ago
    GPL-2.0-only is the name of a license. One word. It is an alternative to GPL-2.0-or-later.
    • kbelder 7mo ago
      Right, the final hyphen changes the meaning of the sentence. "GPL-2.0-only" "GPL-2.0 only"
  • compyman 7mo ago
    You might be being too pedantic :) https://spdx.org/licenses/GPL-2.0-only.html https://spdx.org/licenses/GPL-2.0-only.html It's a specific GPL license (as opposed to GPL 2.0-later)
• martin-t 7mo ago
  This feels like the OSS community is giving up. LLMs are lossily-compressed models of code and other text (often mass-scraped despite explicit non-consent) which has licenses almost always requiring attribution and very often other conditions. Just a few weeks ago a SOTA model was shown to reproduce non-trivial amounts of licensed code[0]. The idea of intelligence being emergent from compression is nothing new[1]. The trick here is giving up on completeness and accuracy in favor of a more probabilistic output which 1) reproduces patterns and interpolates between patterns of training data while not always being verbatim copies 2) serves as a heuristic when searching the solution-space which is further guided by deterministic tools such as compilers, linters, etc. - the models themselves quite often generate complete nonsense, including making up non-existent syntax in well-known mainstream languages such as C#. I strongly object to anthropomorphising text transformers (e.g. "Assisted-by"). It encourages magical thinking even among people who understand how the models operate, let alone the general public. Just like stealing fractional amounts of money[3] should not be legal, violating the licenses of the training data by reusing fractional amounts from each should not be legal either. [0]: https://news.ycombinator.com/item?id=47356000 https://news.ycombinator.com/item?id=47356000 [1]: http://prize.hutter1.net/ http://prize.hutter1.net/ [2]: https://en.wikipedia.org/wiki/ELIZA_effect https://en.wikipedia.org/wiki/ELIZA_effect [3]: https://skeptics.stackexchange.com/questions/14925/has-a-programmer-ever-embezzled-money-by-shaving-fractions-of-a-cent-from-many-b https://skeptics.stackexchange.com/questions/14925/has-a-pro...
  • tmp10423288442 7mo ago
    On https://news.ycombinator.com/item?id=47356000 https://news.ycombinator.com/item?id=47356000, it looks like the user there was intentionally asking about the implementation of the Python chardet library before asking it to write code, right? Not surprising the AI would download the library to investigate it by default, or look for any installed copies of `chardet` on the local machine.
    • martin-t 7mo ago
      The comment says "Opus 4.6 without tool use or web access"
• shevy-java 7mo ago
  Fork the kernel! Humans for humans! Don't let skynet win!!!
  • aruametello 7mo ago
    > Fork the kernel! pre "clanker-linux". I am more intrigued by the inevitable Linux distro that will refuse any code that has AI contributions in it.
    • pawelmurias 7mo ago
      Tardux Linux
• sarchertech 7mo ago
  This does nothing to shield Linux from responsibility for infringing code. This is essentially like a retail store saying the supplier is responsible for eliminating all traces of THC from their hemp when they know that isn’t a reasonable request to make. It’s a foreseeable consequence. You don’t get to grant yourself immunity from liability like this.
  • SirHumphrey 7mo ago
    Quite a lot of companies use and release AI written code, are they all liable?
    • sarchertech 7mo ago
      1. Almost definitely if discovered 2. Infringement in closed source code isn’t as likely to be discovered 3. OpenAI and Anthropic enterprise agreements agree to indemnify (pay for damages essentially) companies for copyright issues.
      • theshrike79 7mo ago
        What would be "discovered" exactly? You can't patent a basic CRUD application. There has to be an analogy to music or something here - except that code is even less copyrightable than melodies. Yes, there might be some specific algorithms that are patented, but the average programmer won't be implementing any of those from scratch, they'll use libraries anyway.
        • sarchertech 7mo ago
          I’m not talking patents. Code is 100% copyrightable. Code being copyrightable is the entire basis for open source licenses.
          • theshrike79 7mo ago
            s/patent/copyright/ in my comment then. What part of a bog-standard HTTP API can be copyrighted? Parsing the POST request or processing it or shoving it to storage? I'm genuinely confused here and not just being an ass. There are unique algorithms for things like media compression etc, I understand copyrighting those. But for the vast majority of software, is there any realistic threat of hitting any copyrighted code that's so unique it has been copyrighted and can be determined as such? There are only so many ways you can do a specific common thing. I kinda think of it like music, without ever hearing a specific song you might hit the same chord progressions by accident because in reality there are only so many combinations you can make with notes that sound good.
• the_biot 7mo ago
  [flagged]
  • _blaise_ 7mo ago
    Linus is the original vibe coder. He barks orders at cadre of human contributor agents and subsystem maintainer agents until the code looks the way he likes.
    • ninjagoo 7mo ago
      > Linus is the original vibe coder. LoL. Jesting aside, OpenHub lists Linus Torvalds as having made 46,338 commits. 45,178 for Linux, 1,118 for Git. His most recent commit was 17 days ago. [1] That is a far cry from a vibe-coder, no? :-) Bit unfair to call his leadership vibe-coding, methinks. [1] https://openhub.net/accounts/9897 https://openhub.net/accounts/9897
      • brcmthrowaway 7mo ago
        Where does gkh come in this list
    • sph 7mo ago
      > He barks orders at cadre of human contributor agents and subsystem maintainer agents until the code looks the way he likes That's called being a manager, not a vibe coder.
• redoh 7mo ago
  [flagged]
• lowsong 7mo ago
  At least it'll make it easy to audit and replace it all in a few years.
• spwa4 7mo ago
  Why does this file have an extension of .rst? What does that even mean for the fileformat?
  • adikso 7mo ago
    reStructuredText. Just like you have .md files everywhere.
  • jdreaver 7mo ago
    https://en.wikipedia.org/wiki/ReStructuredText https://en.wikipedia.org/wiki/ReStructuredText This format really took off in the Python community in the 2000's for documentation. The Linux kernel has used it for documentation as well for a while now.
  • SV_BubbleTime 7mo ago
    Everyone missed a great opportunity to lie to you and tell you that the Linux kernel now requires you to program in rust.
• ninjagoo 7mo ago
  > Signed-Off ... > The human submitter is responsible for: > Reviewing all AI-generated code > Ensuring compliance with licensing requirements > Adding their own Signed-off-by tag to certify the DCO > Taking full responsibility for the contribution > Attribution: ... Contributions should include an Assisted-by tag in the following format: Responsibility assigned to where it should lie. Expected no less from Torvalds, the progenitor of Linux and Git. No demagoguery, no b*. I am sure that this was reviewed by attorneys before being published as policy, because of the copyright implications. Hopefully this will set the trend and provide definitive guidance for a number of Devs that were not only seeing the utility behind ai assistance but also the acrimony from some quarters, causing some fence-sitting.
  • bsimpson 7mo ago
    Signed-off-by is already a custom/formality that is surely cargo-culted by many first-time/infrequent contributors. It has an air of "the plans were on display in the bottom of a locked filing cabinet stuck in a disused lavatory with a sign on the door saying 'Beware of the Leopard.'" There's no way to assert that every contributor has read a random document declaring what that line means in kernel parlance. I recently made a kernel contribution. Another contributor took issue with my patch and used it as the impetus for a larger refactor. The refactor was primarily done by a third contributor, but the original objector was strangely insistent on getting the "author" credit. They added our names at the bottom in "Co-developed-by" and "Signed-off-by" tags. The final submission included bits I hadn't seen before. I would have polished it more if I had. I'm not raising a stink about it because I want the feature to land - it's the whole reason I submitted the first patch. And since it's a refactor of a patch I initially submitted (and "Signed-off-by,") you can make the argument that I signed off on the parts of my code that were incorporated. But so far as I can tell, there's nothing keeping you from adding "Co-developed-by" and "Signed-off-by Jim-Bob Someguy" to the bottom of your submission. Maybe a lawyer would eventually be mad at you if Jim-Bob said he didn't sign off. There's no magic pixie dust that gives those incantations legal standing, and nothing that keeps LLMs from adding them unless the LLMs internalize the new AI guidance.
    • 7mo ago
• themafia 7mo ago
  > All contributions must comply with the kernel's licensing requirements: I just don't think that's realistically achievable. Unless the models themselves can introspect on the code and detect any potential license violations. If you get hit with a copyright violation in this scheme I'd be afraid that they're going to hammer you for negligence of this obvious issue.
  • Joel_Mckay 7mo ago
    US legal consensus has set the precedent that "AI" output can't be copyrighted. Thus, technically no one can really own or re-license prompt output. Re-licensing public domain uncopyrightable work as GPL/LGPL is almost certainly a copyright violation, and no different than people violating GPL/LGPL in commercial works. Linus is 100% wrong on this choice, and has introduced a serious liability into the foundation upstream code. =3 https://en.wikipedia.org/wiki/Founder%27s_syndrome https://en.wikipedia.org/wiki/Founder%27s_syndrome https://www.youtube.com/watch?v=X6WHBO_Qc-Q https://www.youtube.com/watch?v=X6WHBO_Qc-Q
    • kam 7mo ago
      > Being in the public domain is not a license; rather, it means the material is not copyrighted and no license is needed. Practically speaking, though, if a work is in the public domain, it might as well have an all-permissive non-copyleft free software license. Public domain material is compatible with the GNU GPL. https://www.gnu.org/licenses/license-list.html#PublicDomain https://www.gnu.org/licenses/license-list.html#PublicDomain
      • Joel_Mckay 7mo ago
        Yes, if it is clearly labeled as such, than GPL/LGPL licenced works may be included in such products. However, this relationship cannot make such works GPL without violating copyright, and doesn't magically become yours to re-license isomorphic plagiarized code from LLM. For example, one may use NASA public domain photos as you wish, but cannot register copyright under another license you find convenient to sue people. Also, if that public domain photo includes the Nutella trademark, it doesn't protect you from getting sued for violating Ferrero trademarks/patents/copyrights in your own use-case. Very different than slapping a new label on something you never owned. =3
• northstar-au 7mo ago
  [dead]
• NetOpWibby 7mo ago
  inb4 people rage against Linux
  • SV_BubbleTime 7mo ago
    Scroll down, some nerds have no chill.
    • NetOpWibby 7mo ago
      Good grief
• KhayaliY 7mo ago
  We've seen in the past, for instance in the world of compliance, that if companies/governments want something done or make a mistake, they just have a designated person act as scapegoat. So what's preventing lawyers/companies having a batch of people they use as scapegoats, should something go wrong?
• techpulselab 7mo ago
  [dead]
• midnightn 7mo ago
  [dead]
• chaosprint 7mo ago
  [dead]
• bharat1010 7mo ago
  Honestly kind of surprised they went this route -- just 'you own it, you're responsible for it' is such a clean answer to what feels like an endlessly complicated debate.
• feverzsj 7mo ago
  Linux is founded by all these big companies. Linus couldn't block AI pushes from them forever.
  • paganel 7mo ago
    Correct, in the end big money talks.
  • becquerel 7mo ago
    He's been vibecoding some stuff himself personally, on one of his scuba projects. You could take people as actually believing in the things they do and say.
  • simianwords 7mo ago
    This is some ridiculous cope.
    • LtWorf 7mo ago
      True, Linus never believed in free software to begin with.
• KaiLetov 7mo ago
  The policy makes sense as a liability shield, but it doesn't address the actual problem, which is review bandwidth. A human signs off on AI-generated code they don't fully understand, the patch looks fine, it gets merged. Six months later someone finds a subtle bug in an edge case no reviewer would've caught because the code was "too clean."
  • ugh123 7mo ago
    > they don't fully understand, the patch looks fine I don't get this part. Why is the reviewer signing off on it? AI code should be fully documented (probably more so than a human could) and require new tests. Code review gates should not change
  • altmanaltman 7mo ago
    I mean the same can happen with human-written code no? Reviewer signs off on it and subtle bug in edge case no one saw? Or you mean the velocity of commits will be so much that reviewers will start making more mistakes?
• zxexz 7mo ago
  I like this. It's just saying you have responsibility for the tools you wield. It's concise. Side note, I'm not sure why I feel weird about having the string "Assisted-by: AGENT_NAME:MODEL_VERSION" [TOOL1] [TOOL2] in the kernel docs source :D. Mostly joking. But if the Linux kernel has it now, I guess it's the inflection point for...something.
• gnarlouse 7mo ago
  I wonder if this is happening because Mythos
  • gh2k 7mo ago
    this was my initial reaction. It feels like we would rather merge the Mythos/Glasswing fixes before the model becomes widespread. The rumours/vibe are that there are security issues at are going to need responsibly patching before the 0-day exploits arrive. If this means implementing a broader AI contribution policy now, it seems practical.
• rwmj 7mo ago
  Interesting that coccinelle, sparse, smatch & clang-tidy are included, at least as examples. Those aren't AI coding tools in the normal sense, just regular, deterministic static analysis / code generation tools. But fine, I guess. We've been using Co-Developed-By: <email> for our AI annotations.
• builderhq_io 7mo ago
  [dead]
• oytis 7mo ago
  How is one supposed to ensure license compliance while using LLMs which do not (and cannot) attribute sources having contributed to a specific response?
  • Lapel2742 7mo ago
    > How one is supposed to ensure license compliance while using LLMs which do not (and cannot) attribute sources having contributed to a specific response? Additionally there seems to be a general problem with LLM output and copyright[1]. At least in Germany. LLM output cannot be copyrighted and the whole legal field seems under-explored. > This immediately raises the question of who is the author of this work and who owns the rights to it. Various solutions are possible here. It could be the user of the AI alone, or it could be a joint work between the user and the AI programmer. This question will certainly keep copyright experts in the various legal systems busy for some time to come. It seems that in the long run the kernel license might become unenforceable if LLM output is used?! [1] https://kpmg-law.de/en/ai-and-copyright-what-is-permitted-when-using-llms/ https://kpmg-law.de/en/ai-and-copyright-what-is-permitted-wh...
    • theshrike79 7mo ago
      Either you allow LLM generated + human reviewed code or people start hiding AI use. ...and then people start going "that's AI" on every single piece of code, seeing AI generated code left and right - like normal people claim every other picture, video or piece of text is "AI". IMO it's a lot better to let people just openly say "this code was generated with AI assistance", but still sign off on it. Because "Your job is to deliver code you have proven to work": https://simonwillison.net/2025/Dec/18/code-proven-to-work/ https://simonwillison.net/2025/Dec/18/code-proven-to-work/
• cameolkc 7mo ago
  [dead]
• deadbabe 7mo ago
  How can we automate the disclosure of what AI agent was used in a PR and the extent of code? Would be nice to also have an audit of prompts used, as that could also be considered “code”.
• KronisLV 7mo ago
  This is actually a pretty nice idea: Assisted-by: AGENT_NAME:MODEL_VERSION [TOOL1] [TOOL2] I feel like a lot of people will have an ideological opposition to AI, but that would lead to people sometimes submitting AI generated code with no attribution and just lying about it. At the same time, I feel bad for all the people that have to deal with low quality AI slop submissions, in any project out there. The rules for projects that allow AI submissions might as well state: "You need to spend at least ~10 iterations of model X review agents and 10 USD of tokens on reviewing AI changes before they are allowed to be considered for inclusion." (I realize that sounds insane, but in my experience iterated review even by the same Opus model can help catch bugs in the code, I feel like the next token prediction in of itself is quite error prone alone; in other words, even Opus "writes" code that it has bugs that its own review iterations catch)
• Xiaoher-C 7mo ago
  [dead]
• BahaaKhateeb123 7mo ago
  [dead]
• HarHarVeryFunny 7mo ago
  It's a sane policy - human is responsible for what they contribute, regardless of what tools they use in the development process. However, the gotcha here seems to be that the developer has to say that the code is compatible with the GPL, which seems an impossible ask, since the AI models have presumably been trained on all the code they can find on the internet regardless of licensing, and we know they are capable of "regenerating" (regurgitating) stuff they were trained on with high fidelity.
  • theshrike79 7mo ago
    Then we get to the Code of Theseus argument, if you take a piece of code and replace every piece of with code that looks the same, is it still the original code? Is an AI reimplementation a "clean room" implementation? What if the AI only generates pseudocode and a human implements the final code based on that? Etc etc ad infinitum. Lawyers will be having fun with this philosophical question for a good decade.
    • HarHarVeryFunny 7mo ago
      > Is an AI re-implementation a "clean room" implementation Certainly not if it had seen the code (incl. having been trained on it). The idea of clean room (dating back to IBM PC BIOS clones) is that ideas can't be copyright, but the expression of an idea (code) can be, so you have one person (or AI) write a spec of the thing you want to copy (expression -> idea) and then have another (in the "clean room") who has never seen the original code, and only seen the spec/idea, re-implement it. If the re-implementation was being done with AI, then for this to pass as "clean room" it would need to be proved that the AI had never seen the code, only the spec.
      • theshrike79 7mo ago
        But isn't it similarly impossible to prove that the AI used an exact copy from a specific project that didn't have a permissive license? I get it that lifting a full-ass function as-is from a project is bad, but if you construct a function that does the same thing by aggregating bits from different projects - what then? There HAS to be moral and legal issues there, but what and where? Stealing other people's code is bad, but we do also have to admit that the vast majority of code in the world isn't doing anything groundbreaking that deserves a copyright. Or is it illegal to write a Hello World application after the first ever in that language was written and published, doesn't the copyright for that code exist on the first creator - and everyone else is in breach of their copyright or has to prove they had no prior knowledge of the code? (You can replace "hello world" with any trivial piece of code everyone writes a zillion times routinely). This whole thing is so wishy-washy and vague it's giving me migraines. I don't WANT to break any laws, but holy crap it's not easy to figure out where the actual limits are.
• sheepscreek 7mo ago
  This is the right way forward for open-source. Correct attribution - by tightening the connection between agents and the humans behind them, and putting the onus on the human to vet the agent output. Thank you Linus.
• eddie-wang 7mo ago
  [dead]
• aprentic 7mo ago
  I like this. It's an inversion of the old addage, "a poor craftsman blames his tools" and the corollary, "use the right tool for the job" (because a good craftsman chooses the appropriate tool). You don't get to bang on a screw and blame the hammer.
• WhyNotHugo 7mo ago
  Weird that they're co-opting the "Assisted-by:" trailer to tag software and model being used. This trailer was previously used to tag someone else who has assisted in the commit in some way. Now it has two distinct usages. The typical trailer for this is "AI-assistant:".
• techpulselab 7mo ago
  [dead]
• MyUltiDev 7mo ago
  Reading this right after the Sashiko endorsement is a bit jarring. Greg KH greenlit an AI reviewer running on every patch a couple weeks back, and that direction actually seems to be helping, while here the conversation is still about whether contributors will take responsibility for AI code they submit. That feels like the harder side to police. The bugs that land kernel teams in trouble are race conditions, locking, lifetimes, the things models are most confidently wrong about. I have seen agents produce code that compiles cleanly, reads fine on a Friday review, then deadlocks under contention three weeks later. Is this contributor policy supposed to be the long term answer, or a placeholder until something Sashiko-shaped does the heavy filtering on the maintainer side too?
• rao-v 7mo ago
  A phenomenon I can not explain is the fact that this simple clean statement of a fairly obvious approach to AI assistance somehow took this long and Linus to state so cleanly. Are there other popular repos with effectively this policy stated as neatly that I’ve missed?
  • bonzini 7mo ago
    The wording might be more or less lawyerly but the idea is fairly common, e.g. https://openinfra.org/legal/ai-policy https://openinfra.org/legal/ai-policy (OpenStack).
    • rao-v 7mo ago
      This is very good! It captures the core idea that "As a contributor, you are responsible for the code you submit" that the other example doesn't cover. Perhaps a nit is that it's a little too OpenInfra policy specific. Is it fair to say it got to it's near final form mid 2025?
      • bonzini 7mo ago
        Yes, that's fair.
  • phillipcarter 7mo ago
    We've had this for a while now: https://github.com/open-telemetry/community/blob/main/policies/genai.md https://github.com/open-telemetry/community/blob/main/polici...
    • rao-v 7mo ago
      A very nice example, and more kind and welcoming than most. When would you say it reached it's near final form? Git blame suggest about 7 months ago or 3rd Q 2025?
• agentultra 7mo ago
  How do the reviewers feel about this? Hopefully it won't result in them being overwhelmed with PRs. There used to be a kind of "natural limit" to error rates in our code given how much we could produce at once and our risk tolerance for approving changes. Given empirical studies on informal code review which demonstrate how ineffective it is at preventing errors... it seems like we're gearing up to aim a fire-hose of code at people who are ill-prepared to review code at these new volumes. How long until people get exhausted with the new volume of code review and start "trusting" the LLMs more without sufficient review, I wonder? I don't envy Linus in his position... hopefully this approach will work out well for the team.
• maroondlabs 7mo ago
  [flagged]
• gorgoiler 7mo ago
  Having the competence to put together a good patch used to be a proxy that you were motivated to stick around and fix any regressions you caused and that you were worth investing in, as a community member. Or, to put it another way, in the old days in order to be a 3k-LoC PR wielding psychopath intent on making your colleagues miserable with churny aggro diffs from hell you at least had to be good at coding. Nowadays, you only need to do the psychopath art — Claude will happily fill in the PR for you.
• laurakalninaaa 7mo ago
  [dead]