There's a lot said about LLM-generated vulnerability reports, but LLM-generated bug reports in general are a huge problem because of the underlying economics. Every bug fix has an obvious benefit (the bug is gone now) but has some additional costs:
First, there is the opportunity cost. You have to spend time reviewing the bug, creating the fix, and reviewing the fix. That is time that is spent on that is not spent on other things. If a bug has no security implications and is almost impossible to trigger, then it should be low priority. Writing bug-free code is impossible. Even the best formal verification techniques don't save you when your specification is buggy (to give a concrete example: EverCrypt was formally verified with the property for temporal memory safety that no object was accessed after being deallocated. The spec forgot to mention that objects should be deallocated at some point). Fixing bugs is always a tradeoff and there are almost certainly bugs that will impact more users that you could have been fixing while you were instead triaging and fixing something an LLM produced.
Equally importantly, the bug fix may introduce additional regressions. This is especially true for LLM-generated fixes. I've had several bug reports where someone has had the LLM generate a test case and then use that (plus the rest of the test case) as the fitness function for generating a fix. This has a number of common failure modes. Sometimes the test case triggers a specific failure path, so you can fix that path without fixing the underlying root cause. Sometimes the test case is entirely spurious (for example: API misuse) and the fix introduces some significant performance regression, where the original failure mode was a deliberate choice to crash in particularly unusual cases rather than taking a 10% performance hit in the common path.
This isn't new to LLMs. We saw exactly the same thing with static analysis. If you ran a new static analyser on a large existing C codebase, you'd typically see thousands of reports. Some were security issues. Some were real bugs that would likely affect users. Some were real bugs that would be unlikely to ever be triggered in the real world. Some were false positives. Going through all of them and finding the ones that actually mattered was incredibly hard.
The problem is never 'find more bugs', it's always 'prioritise the bugs that actually matter'. Some of the LLM-based approaches are helpful here for providing an exploit path, but LLMs are typically too flexible here. They'll often generate test cases that are outside of your threat model, or which misuse APIs in a way that allows callers of a library to break themselves (which they can easily do without the library). So even triaging from the test case is tricky.
Unfortunately, determining the real-world impact of a bug depends on a lot of extrinsic knowledge. LLMs will try to infer this but it varies hugely between codebases and so a statistical approach often gives a very wrong impression.