Development statistics for the 7.2 kernel
lwn.net
lwn.net
The agent helps a lot to fix bugs. Just point the agents at the bug reports. They do the reproduction, debugging and fixes. We "just" have to review. (Sometimes ask more details and tell we'd prefer another approach.) This makes bug fixing much faster and automated.
And at the same time, it seems we get less bug reports to our library. I think user just use their agents to code, and agents don't report bugs, they just work it around somehow.
So overall, the open bug count is decreasing. Which somehow feels good.
On the other hand, we get a lot of PR made by other's people agents, which can be a bit overwhelming when it's just a huge code drop. We can't easily review that.
Yeah I've definitely noticed this. On a project I'm working on Opus 5.5 found a bug in Smithay and another in Winit. It did tell me about them but its preferred solution was just to work around them locally. To be fair we don't really want agents going off and reporting bugs automatically...
I don't run any big open source projects but I think my preferred solution to AI PRs would be to get my AI to implement the same thing, and give then afterwards tell it to look at the PR for anything it missed. Then I at least know that I'm using a competent model and it reduces the danger of just blindly accepting someone else's code. (And obviously review the code if you have time and care, but that isn't always the case.)
Claude comes up with some truly delicious insane workarounds these days. Like launching something in a subprocess and capturing stdout/stderr and doing string parsing on info logs because of a desire for some hook not exposed by API (or at least that it didn't find on its quick scan).
There's probably no such thing as semver reliability for dependencies anymore in stuff that agents glue together, since they will poke at ANY sort of way of getting additional insight or control if they want it.
Rsync is hopelessly underfunded under staffed. Current developer was forced to takeover, because everyone quit!
It's quite a pity, preventing us from improving our model of the domain, from Naurian theory building and presenting a perfected API etc.
From the last paragraph:
"The Linux kernel is aimed at production use, not research or experimentation. But there is currently a massive experiment being run on the kernel's development processes and community."
"This community has absorbed new processes and tools many times over its 35-year history, and will almost certainly find a way to do that this time as well. But that absorption has not always been without turbulence along the way."
Which covers how he responds and pushes back on much of this, as well as asking for a patch (not just bug reports)
He's "pushing back on this" because he's being obsoleted in real time.
Seriously doubt there's much of value there.
Historical numbers are not valid because incentivizes of a well funded entity have changed. It would require an equally well funded push to up the patch numbers without LLMs to really measure the impact in a quantifiable way.
YMMV
(Edit: title has been fixed)
Submitters: If you want to say what you think is important about an article, that's fine, but do it by adding a comment to the thread. Then your view will be on a level playing field with everyone else's: https://hn.algolia.com/?dateRange=all&page=0&prefix=false&so...
Why? He seems very pragmatic. I fully expected him to embrace it, with the only concern being correctness and quality.
The ones complaining about "slop" are the ones going on vibes now.
I hear people around me talking about a bad experience they had with ChatGPT last summer as though it proves all AI coding is “slop”. Honestly, it makes me sad for them. There are reasons to dislike AI, but so many detractors skip right past those to anecdata that just aren’t relevant anymore, if they ever were.
To counter the bad though: right now Claude and I have been doing some very interesting work on acoustics and advancing steam audio. I've been researching this for several years trying on and off again to make my hopes a reality but could never take all the math and make something coherent out of it by hand, and Claude has helped with that (well, and Steam Audio). The trouble mainly comes from being blind and trying to build geometry from code and not being able to mentally visualize the geometry in question (which is also why I struggle with physics engines). It's been really fun just experimenting with this and seeing how good it gets. Who knows, I might make it a library that I publish someday.
They always quit right before it got good.
> Honestly, it makes me sad for them.
The the consternation? They’re going to be obsoleted in no time anyway, so we’re told. Are they missing out on some months’ worth of coasting as meat proxies before exponential takeoff? Is that the sad part?
* Why the
Again, he's pragmatic, and has seen countless types and iterations of tech come into existence. The people expecting perfection from the start have no actual experience with the creative process, engineering or design, and and only want progress to stop (because there is, literally, without exception ever existing, no alternative to iteration).
20 years ago he was fine using BitKeeper, proprietary software, for kernel source control, because it was better than Subversion and CVS. He only created git when BitKeeper introduced some road blocks.
It honestly doesn't want to make me open anything for outside contributions anymore.
https://lore.kernel.org/lkml/CAHk-=whTs09_ozN+e09GU68N1wPP56...
He used Claude Code to write one of his patches in [0] and introduced a data race bug in the kernel unbeknownst to himself but this bug was caught by other reviewer [1] before it made it into a new kernel release.
So I'm afraid Linus himself did not understand the changes Claude made to the code he submitted in the mailing list, despite his "principles" in telling others previously that AI was creating slop patches and then now shouting at others who were concerned about using LLMs on code where they do not understand the generated code themselves when it all applied to....himself.
What other reading of this is there? A bug is being cited as evidence of slop generation, which implies pre-AI the bug would not have happened.
That effectively makes it a strawman argument.
We are talking about this bug, in this context. Not about pre-AI bugs that did happen and that also were caught (and then there is of course all the ones that were not caught).
Yes, that's why the parent poster's argument is bunk; it implies we know.
The patches that Linus posted are relatively small and self contained and from reading the thread it seems came from a series of in depth conversations with Claude and were carefully reviewed by Linus.
So what we're seeing here is a tricky concurrency bug that even an expert would make. You can't use it as an example of slop
> Because if you can't show that you really understand what the machine is actually doing by writing your code in assembler, then I don't want to see your code contribution. You clearly aren't competent if you can't write it that way.
Typical AI sophistry. But it’s from Linus Torvalds so it becomes a slam-dunk.
> The kind of expectations I have is that people do their best and I expect people to understand what they are doing.
> But that understanding has very little to do with what tools they use.
> And quite honestly, in my experience, the people I respect and call intelligent are not the ones that shy away from using new and interesting tools.
He’s saying that understanding or competence are more about the person than their AI use. I think that’s a reasonable argument, even though I disagree on the basis that it’s at least a little correlated in the shortcuts in understanding the many devs I’ve seen (not all, but a nontrivial amount) seem to be taking.
My point was basically that this question misunderstands the purpose of large open source projects. They are not primarily things people have a right to contribute to, but rather things we want to improve for everyone. Anyone has the right to make changes to the Linux kernel for their own purposes, but contributing is not a right. It is primarily for serving the public good.
I’m not surprised the processes discourage some portion of would be contributors from contributing. I just don’t think that is a problem.
Projects like the Linux kernel do not pop up out of thin air. They need a leader.
> Here's a new rule just for you: don't use compilers for any of your kernel submissions.
> Because if you can't show that you really understand what the machine is actually doing by writing your code in assembler, then I don't want to see your code contribution. You clearly aren't competent if you can't write it that way.
The point is, new technology arrived that allowed developers to do much more. Existing programmers hemmed and hawed about it because it threatened their egos, making easy what they once found very difficult. But the sensible engineers adopted the technology.
AI may not be deterministic, but on small to medium-sized tasks it produces more correct code, more reliably, faster than a human developer does. By any objective measure, not adopting it is professional irresponsibility.
How do you define correctness for any given task? If you know the correct logical process for any given process, writing it in code is just a matter of typing. The issue is that the human author, even when assisted by AI tools, does not know what is the correct algorithm for the task. In most cases, the output is probable code, not correct code.
If the answer is no, then AI agents producing code faster and "more correct" (in some arguably questionable sense but let's fly with the assumption for a moment) should be embraced fully. Take the humans out of the loop, why review code, if there is a problem later then just ask the next AI agent to fix it. Similar to not looking at generated code by a compiler. Iterate fast, don't look back. Some code bases and some entire companies have adopted this view.
If the answer is yes then we need to keep the human in the loop, ensure they have enough understanding to maintain the thing, review all the code etc. AI is just another tool to produce the code which ultimately the human still owns. Many code bases follow this philosophy.
It seems to me that the discussion always ultimately falls on one of these two sides. They are incompatible but you need to pick one. Depending on which you pick, it is easy to predict how you argue in such discussions.
Understanding the implementation is not the root cause here. The actual issue is that all software are built for a particular needs which is human related. In most software, the cost mostly decays to a constant value unless that need has changed or an external event has occurred.
Embracing AI fully is keeping the software in constant flux as it can’t guarantee it will actually follow the requirements and the platform specs. Any prompt has a non zero chance to introduce regressions and breaking changes, disrupting the workflow of the users.
The tools to write the code does not matter to the user just like the hammer does not matter to the person that needs a home. But if your tools results in a badly constructed house that always needs repair and what not, expect complaints.
You can pin down existing expected behavior pretty well with automated test cases and even bringing formal verification into the mix. Using LLMs to create those, it's not even a major cost factor. Then you are safe from such regressions. Just like when humans make changes. So, I don't see how this is introducing a difference.
> The tools to write the code does not matter to the user just like the hammer does not matter to the person that needs a home. But if your tools results in a badly constructed house that always needs repair and what not, expect complaints.
Indeed. Though I don't see the connection to my point.
Test cases are sample based, they do not take care of the whole range of input and output. Type checking in the other hand are set based and sometimes the types are too coarse. In both instances, you need to carefully choose your axiomatic foundation, and if you can do that, that means you’re already aware of both programs and solution. As defining the problem is a major step in problem solving.
> Indeed. Though I don't see the connection to my point.
A lot of AI proponents are touting the tools as better hammers while purposely not saying anything about the house. You need to show how it can help with building a new house and not gush that it’s a new shape, different from all the other hammers in history.
So the focus on line of codes, number of PRs, all the harness talks,… is worth nothing if better software can’t be built.
Indeed, but they are not random or arbitrary. They are typically the inputs that matter, and if chosen carefully then they cover all interesting/relevant inputs from the vast space. If you want to make things water tight, you use formal verification like I mentioned earlier (of which type checking is just a lightweight variant, in a sense) but for general screwups that's not even necessary. If tests are chosen well then the code must be formed very weirdly to produce bugs that the tests would not find.
The thing is you can have code that passes the tests, but are wrong for the general cases. With manual coding, you will have the knowledge that the code is about right, then add test cases to precisely check that intuition.
Like being aware that you used a linear function so as soon as 2 points in the test are ok, the code is right. But if you don’t read the code and have not noticed the quadratic function, your test cases will pass while the code is incorrect.
If anything then I would expect a human to be more susceptible to such an error than a coding agent. At least frommy experience from how they deal with (admittedly test-heavy) code bases.
(But again, if unsure, add a formal correctness proof for a few more extra tokens if that makes you sleep better at night.)
> AI may not be deterministic, but on small to medium-sized tasks it produces more correct code, more reliably, faster than a human developer does.
That is not remotely true.
Please provide examples of bugs that a human would "never introduce", ever, under any circumstance whatsoever.
i work on the codegen for a C compiler i'm pretty sure my understanding is better than yours <shrug>
EDIT: and also you've clearly never read that article
> One of the key attributes of a low-level language is that programmers can easily understand how the language’s abstract machine maps to the underlying physical machine
so you did exactly imply "C is a low level language"
The idea that C is a smol language that can be completely understood by one person is one of those myths that need to be put to bed. C is riddled with complexities and footguns, especially but not exclusively around undefined behavior.
You don’t need to understand the language completely. You only need to understand the general semantics and refer to the standard and docs to get the semantics down. That’s what they’re here for.
Linus wants the bugs fixed.
New leadership is needed over there.
No, it's not a fair suggestion, because it's not a real suggestion at all. Over 2000 skilled maintainers work on the kernel, there's hierarchy, processes, culture, community, the linux kernel project both adapts to and shapes computing globally, companies are in talks with the linux foundation in regards to drivers etc, distros are tightly coupled and tested on it, there are north-star people like Linus... It's very much a big ship.
So firstly, yes, there IS something "standing in the way of anyone forking a kernel and building their own version" - for example that it's absolutely useless, unless you can do the job of 2000 maintainers, your "fork" will be the upstream base + 3 little patches on top and you'll spend a month getting it stable on your system.
Secondly, this isn't something you solve by saying "screw it, I'll do it myself" and abandoning the ship. Even if you did build your own linux kernel to your liking, this doesn't address the concern about the global linux kernel project that other 99.9% of the planet and distros and hardware uses.
This "don't like it? Fork it" argumentation fallacy has been present ever since open source became a thing, and it's quite frankly insufferable, but applying it to the goddamn Linux kernel, that's a new level.
atlantic 0000:0f:00.0: PM: failed to resume async: error -12
AI fix this, thanks