There appears to be a few bad actors in the Lemmy community spreading ragebait for personal gain
In fact, the same mechanisms added at the beginning to catch bad human written code are the exact same that catch bad AI code
- No, the Linux kernel DOES NOT use AI to automatically approve code for inclusion. As far as I can tell, there are no plans to do so
- The Kernel actually has a huge number of maintainers. As part of the process, all patches are reviewed by a human who provide feedback as part of the process, and patches get bounced back and forth multiple time.
- Patches don’t just magically go straight to master. The maintainers generally have their own branches where it goes to, then it goes to staging trees like Linux-Next. It goes through many eyes, and many tests by the end. The idea that AI code is overrunning the kernel is rediculous
- Maintainers also check that the code meets coding guidelines and is written properly, and solves the problem they are trying to solve. Yes, they also ensure the code isn’t slop
- LLM’s though might be used to identify obvious problems with the code (which they are VERY good at), or even identify code that doesn’t follow coding guidelines.
- The only thing that matters is the human who submitted the code, as they should be checking the code submitted anyway (including LLM generated code)
Writing bad code isn’t something new, and isn’t unique to LLM’s. Coders (and it seems some “journalists”) have been writing slop since computers were invented.
The process hasn’t gotten less stringent (probably even MORE stringent as there is an additional set of robotic eyes that can also check), and the same mechanisms that were put in place to catch badly written code 10 years ago, are still there now… With no changes.
Do you know that Linux kernel has hidden DRM in it? Total betrayal, don’t know about you guys, but I’m no longer going to use it.
Source?
How many of you commenting here have skin in the game?
There is truth to every bit of propaganda. AI is being used in a limited fashion on the Kernel. In the long term AI will likely decrease the contributors as already seen with AI blowing up some traditional communities. This is a very real problem and people should be concerned.
The sky is not falling. The future is very uncertain though and this could be the start of something very disruptive to the open source community.
There is truth to every bit of propaganda
This is not true.
In the long term AI will likely decrease the contributors as already seen with AI blowing up some traditional communities.
I do not agree to the AI hype, but I doubt that. The vast majority of the kernel code is hardware device drivers because one of the main functions of the kernel is hardware abstraction. Hardware is made by companies and being able to use ai will not reduce, rather increase their willingness to submit open source device drivers. If they do not, LLMs also seem to make it easier to reverse-engineer closed source Windows drivers.
Another thing to keep in mind is that the Linux kernel is quality-wise far above 99.9% of software projects. This means that you cannot apply observations of the effect of GenAI on software in general on the kernel, and also not vice versa.
The average usage of GenAI could totally trash 99% of company code bases within four or five years, and the kernel would still be fine.
Also, the way the kernel allows usage of LLMs is not necessarily a good blueprint for other open source projects, because these have less expertise, resources, and people which are experts in reviewing alien code.
However, we currently don’t whether LLM-generated code is libre software yet. Software Freedom Conservancy currently thinks otherwise, the Free Software Foundation is working on it with their lawyers. Whatever the outcome, it seems there will be a huge impact on licensing and perhaps new threats from proprietary software companies.
Yes, that’s true. In that aspect, it would be better to have an LLM which is trained on GPL code only and which returns copyleft licensed code.
However, I think using LLMs for code analysis is not affected by that. Maybe there will turn out a legal difference between code that is entirely LLM generated and code where humans do most of the editing.
One popular legal position is that LLM generated code itself is not subject to copyright law. That might be re-adjusted if the LLM has actually regurgitated training code.
I agree with you that the Kernel isn’t doing slop. But there are a few points I want to address, maybe even disagree. First let me say that people have different definition of what slop means. That is why we don’t always agree on statements involving slop.
he Kernel actually has a huge number of maintainers.
True, but its still not enough to handle all slop. One problem is, its not always apparent at first glance. And more code is generated than ever before, surpassing the capabilities, time and nerves of all maintainers. That means they start using Ai to combat the amount. And that’s an issue on itself.
Writing bad code isn’t something new, and isn’t unique to LLM’s. Coders (and it seems some “journalists”) have been writing slop since computers were invented.
This might be true, but that is not a reason to accept or normalize slop. It does not matter how much slop was before, we always try to minimize it. The difference to before is, that nowadays its easier and faster to write (or generate) slop in mass that looks legit. Finding out its bad code or wrong can suck up huge amount of time of maintainers, which would have worked on something more productive instead.
The only thing that matters is the human who submitted the code
For you maybe, but there are issues using Ai regardless of how the code looks. And I don’t even talk about the amount of code it can generate and outpace every maintainer capacity. I mean stuff like how the LLM was trained on in example, and if the licensing will become an issue one day.
While the Linux Kernel operates very securely and in a controlled manner, that we cannot call it slop (yet). But there are inherent problems using Ai that are unsolved.
It does not matter how much slop was before, we always try to minimize it.
There is no policy that will stop that. It’s happening whether you want it to or not.
What every project needs is a way to handle submissions that ensures a level of quality. The kernel has this. Also needing to police whether code was llm generated would be an increased burden.
Writing bad code isn’t something new, and isn’t unique to LLM’s. Coders (and it seems some “journalists”) have been writing slop since computers were invented.
Yeah, this was the dumbest point OP made IMO, there are non-experienced people but they don’t become Kernel maintainers or contributors. He’s admitting LLMs slops this up and LLMs are yet Kernel maintainers and contribitors.
True, but its still not enough to handle all slop. The number of maintainers have also grown though dramatically… Also, don’t forget that LLM’s can also be used to identify bugs in patches more quickly too… So, more are getting submitted, but, lots of bad patches are being rejected faster too, with less effort (that required human intervention in the past).
This might be true, but that is not a reason to accept or normalize slop. Define Slop…
The difference to before is, that nowadays its easier and faster to write (or generate) slop in mass that looks legit. Finding out its bad code or wrong can suck up huge amount of time of maintainers, which would have worked on something more productive instead. We’ve all spent hours doing that though on our own code. Again, the buck stops with maintainers. One thing that Maintainers are going to do though, is get them to prove the code first and test the code in other trees first, before even trying to push to main
There’s always been code that has been bad, like Linus never liked the Con Kalivas performance patches, or Reiser4.
It is also finding a lot of security issues and bugs faster too though
I’ve actually written optimisations for code that I thought would be faster, and turned out to be a waste of time in production
For you maybe, but there are issues using Ai regardless of how the code looks. Both sets of code need the same level of examination by humans anyway. In fact, in some cases, the AI code I’ve seen has been better than the code i wrote
I mean stuff like how the LLM was trained on in example, and if the licensing will become an issue one day. That is true, and I agree with that. That’s the one point that does stand out, but doesn’t have anything to do with the claim by certain people in the community about the Linux Kernel being overrun with bad code.
What I would like to see is a LLM that’s developed exclusively using Open source compatibility licences with FULL traceability to sources uses, and a way to specify licencing allowed (or something similar).
There is one issue with AI that you didn’t mention however. The biggest problem with AI is that it adversely benefits closed source companies via Open source code. Because closed source code isn’t easily accessed by the AI for training, but Open source is. The other issue is that hackers won’t avoid LLM’s based on the ethical issues, so, unfortunately, it forces developers to use them to keep up with the cat and mouse game.
As a developer, am I happy about AI? For code review yes, but, it makes my job suck and not fun. And no, I’m not happy about the ethics… There are a lot of things that sh** me, like AI companies SHOULD be forced to pay royalties to everyone they stole info from.
However, what sucks, is that we can’t pretend it’s not a thing, and if Linux wants to remain competitive, it does need to use it.
The best thing we can do though, is petition to tax AI companies and pay producers of the information. That would make AI unprofitable immediately and kill the industry
Nobody ever remembers the environmental issues of using AI, like climate change and displacement of poor people. And that’s happening inside the Evil Empire itself, imagine what will do to the rainforest and other ecosystems.
Everyone knows about that… But, that doesn’t have anything to do with “AI Slop”. that comes down to ethical factors and is unrelated to the quality of the code
Funny that someone thinks it’s acceptable to compartimentalize the main issue with AI usage while being trigger happy to label outcry as bad actors.
What I would like to see is a LLM that’s developed … with FULL traceability to sources uses,
That’s not really possible. I mean, you can list the training data, but you can’t attribute a specific output to a specific piece of training data, because all of the training data influences all of the weights. It’s not possible to know which training data influenced which weights and how, because that data is not retained (and it would be massive and difficult to interpret if it was -on the order of weights × number of training context windows, and the weights alone are already terabytes)
Because closed source code isn’t easily accessed by the AI for training, but Open source i
Besides all those Ai users, where code is uploaded to their servers.
On commercial accounts, you can turn off training, and they have policies generally to avoid code leaks (another bad thing for open source, the free accounts you generally can’t, because you are the product).
If you believe that they’re not using corporate code to train their models… These guys are all total lying sociopaths who think they’re on a mission from the machine god, everything is permissible in their minds.
I work for a HUGE organization that uses all the big AI companies products. We have a contract for each that specifies that they MUST NOT train their models with our code.
If they do it anyway, my employer’s vast teams of lawyers will make them take out brand new billion dollar loans to pay off the settlements. They might not even survive such a lawsuit because if they were caught using our code you can bet your ass they used everyone else’s that has a similar contract.
I think in a sane world that would be the outcome. But this world (and particularly the AI cultists) is not sane.
I also worked at a couple of huge corporations (which are both major hyperscalers) and they tried to steal ip from each other pretty much continuously, that was one of the reasons that you had to keep switching companies to advance your career.
Look at how open AI straight expected candidates to bring development models of upcoming Apple devices to interviews. These dudes are more degenerate than you think, I promise.
I think 90% of anti-linus and linux posts tgat we’re seeing are microsoft/apple psyops campaigns. They’re milking this as much as they can
People hate AI because they were told they would not be able to get a job anymore, and many people got fired over it.
Nah, they have worse problems (in case of microsoft) or a completely different market (apple) to give a damn about this.
even identify code that doesn’t follow coding guidelines.
Code linters have existed for decades, that doesn’t require LLMs
That’s how I feel about autocompletion and scaffolding, we’ve had LSPs and code generators for years, and they’re exponentially less wasteful
Not all guidelines are enforceable with linters. For example one of our code bases at work defines when to avoid mock tests, how integration tests should look like, how a module’s architecture is supposed to be, how the naming convention for components of the different layers are, etc.
Those are super ugly to formalize into a linter but super easy to check with an LLM.
Huh. Really? How is the LLM checking it? Is it writing code to check those specs, or are you just along it directly if the code matches the specs?
Normal text based analysis; which LLMs are pretty good at. So our coding agents can follow the rules during development and the review agent can follow it during review. Only static code checks are enforced in the CI pipeline; the review agent only leaves remarks. If we decide to not give a damn, we can still merge it. But its hit-rate is relatively high; so typically when it finds something, it’s valid and its recommendations for fixes are also often pretty good. This helps already iterating on a PR on your own before you pull human reviewers in.
AI code review finds a lot more bugs (such as logic bugs). But yes linters can be used for that specific case
There appears to be a few bad actors in the Lemmy community spreading ragebait for personal gain
There’s no reason to attribute it all—or even most—to malice or opportunism.
I’ve seen some rage bait and people spreading falsehoods about Linus and his outlook on LLMs… but what personal gain is there to be had? I would’ve assumed all the misinformation I’ve seen is just doomerist outrage.
I’m not a participant in Linux development, are you a kernel developer/change reviewer?