← Back to context

Comment by senderista

6 hours ago

Linus's claim that use of LLM tools is uncorrelated with understanding or competence is ludicrous.

What he actually said was:

> 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.

  • To be clear: I believe that it's entirely possible to use LLMs to amplify understanding and competence, but that in practice LLM usage is anticorrelated with understanding and competence. This is about empirical reality, not logical entailment.

    • Very much this. Experimentation and careful usage is ok, but we’ve all seen that is pretty much dwarfed by blind slop generation.

As an example, I’m in the process of putting up a patch series to optimize some specific filesystem operations. The amount of boilerplate that has to know to get done is completely unapproachable to an outsider both from the amount of time needed to learn that boilerplate and form it in such a way that maintainers will be happy. Even though I know exactly how the code is working, it bridges that understanding gap but I don’t see how it correlates with incompetence. I may be an outlier but I suspect there’s a huge amount of people who are extremely capable and competent and it’s just that the Linux kernel has so many processes that it’s difficult to onboard into the community without LLM assistance.

  • The Linux kernel project is not hurting for contributors nor was it prior to LLMs. The processes you describe as roadblocks don’t seem to have been preventing the Linux kernel from getting code contributions. Maybe they don’t need or want more easy onboarding or broader audience?

Presumably the person who's full-time job is staying on top of proposed changes to the linux source tree knows something about this; what are your credentials on the topic?

Linus himself is actually comically incompetent. He only became famous after the Linux kernel took off... decades ago? Since Git, he has made ZERO code contributions whatsoever (not even to the Linux kernel). He doesn't even review code and has his team of capos do it for him. All in all he's no different than the CEO of some tech company, his thoughts on LLMs are no longer relevant (for more lack of credibility, see his stance on Rust, C++, Go)

  • Why does he need to write code to be "competent." He's a structural and architectural genius.

    Projects like the Linux kernel do not pop up out of thin air. They need a leader.

how do you feel about his analogy

> 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.

  • I feel like you can't compare deterministic tools to non-deterministic ones so not a great analogy.

    • It doesn't really matter.

      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.

      6 replies →

    • the question is about whether you understand in the slightest the output of the tool. does the determinism of the compiler somehow imbue you with a better understanding of the assembly it generates?

      8 replies →