you are viewing a single comment's thread
view the rest of the comments
[–] 15 points 1 day ago* (4 children)

That quote was someone else

"LLMs are good enough now," said Greg Kroah-Hartman, a veteran Linux kernel maintainer, at the Linux Foundation's Open Source Summit in South Korea in August. "They've gotten good enough to find bugs because LLMs, AI, are just pattern matchers and code is nothing but patterns in a specific format."

Also to be fair, that quote is about finding bugs and the guy might not have been talking about using AI to patch them. The article makes it sound that way, but the article also seems overly confident and pro-AI about some other things too.

You can deterministically find something that is clearly defined, but bugs don't fall into that category

  • source
  • parent
  • hideshow 4 child comments
  • [–] 10 points 1 day ago (2 children)

    I know, but even regarding bug catching, there have been a LOT of bogus bug reports "discovered by AI" that could not be replicated in any way, shape or form. Granted, I've seen one or two articles saying that AI helped find real software bugs, but what's the ratio there, 1:500 for useful/useless AI bug reports?

  • source
  • parent
  • hideshow 2 child comments
  • [–] 2 points 18 hours ago

    Granted, I’ve seen one or two articles saying that AI helped find real software bugs, but what’s the ratio there, 1:500 for useful/useless AI bug reports?

    It's worth distinguishing between LLM generated bug-reports submitted by randos, and developers themselves using LLMs to look for bugs in their software.

    My own experience, with my own code-bases, is that the LLM I use is extremely good at finding real flaws in my code. It'll also nitpick a lot, but it has has become better at triaging issues than it used to be, so that kind of thing is easy to ignore.

    Because of that, having an LLM take a look at my code before I push it has become another QC step, along with running tests, linters, and formatters. The end result is higher quality software

  • source
  • parent
  • [–] -4 points 1 day ago*

    bogus bug reports “discovered by AI” that could not be replicated in any way, shape or form

    And we NEED to be more serious about use of secure verifiable identities for people so we can properly filter inputs from internet contributions. Anonymous sources should be de-prioritized to just above the known consistently bad actors. That's nothing about AI or LLMs, that's just the world continuing to be far too trusting of basically anonymous contributions.

    If you want to submit a bunch of AI slop under your secure ID, be prepared for that ID to be de-prioritized beneath anonymous contributions.

    If you want submissions from your secure ID to be taken seriously, at least task your LLM with building a proof-of-concept replication of the bugs in the reports your other LLM session creates before submitting it for humans to spend their time evaluating.

    We have a human test department overseas that gets a little eager to pump up their metrics once in a while, we haven't resorted to penalizing them (yet) but when they send an "observation" with no way to reproduce it, no log files to back it up, we tend to ignore that observation until the review meeting and then in the review meeting ask "have you seen this again? do you have any way to reproduce it? do you have screen shots or log files?" and when all those things are missing, the observation is closed with a "cannot reproduce" tag, waiting for another tester to see it again and produce more evidence.

  • source
  • parent
  • [–] 0 points 1 day ago

    the article also seems overly confident

    Anybody writing articles about AI, or evaluating articles about AI, needs to get very specific: what month are they talking about, because if your reference point for "overly confident" is based on where things were 8-12 months ago, that's very different from where things are today, and many times experts in the field project progress to what they expect for the future - that is of course unreliable speculation, but so far most of the reasonable optimism from the last year or two for progress in LLM software authorship and maintenance proficiency has been borne out in reality. I'm not talking about the "software is solved" numbskulls, but the progress in terms of being a valuable tool set the way C compilers were valuable tools to former Assembly programmers - yeah... it's gone there.

    I also recall trying to use Borland Turbo C++ in 1991 and abandoning it because it was too buggy, wrote the project du jour in C instead, saved the C++ rewrite for 1996.

  • source
  • parent