Comment by jumploops
12 hours ago
> For example, in testing by the investment firm Millennium, Fable 5.1 found the cause of a rare crash on their internal systems that none of their engineers (or any other model) had been able to explain after several years of trying.
Say what you will about LLM-generated code, but stories like this give me hope that software will never be as buggy as it once was.
Software will be buggier than ever but also way less buggy.
It's going to be 50% less buggy, but we're going to write 10x as much code too.
Good software will be good-er. Bad software will be nightmare fuel.
I think bad software has the possibility of redemption with rewrites and re-engineering efforts. For those of us who are license locked that's probably never going to benefit us :(
bad software will be replacable.
1 reply →
Time-to-fix is lower, but time-to-new-bug is also lower
The marketing here trick is, if they spent the same money on humans they'd have found it years ago.
Instead, the lurking variable here is new budget was added. With the new budget, they added a new tool, and the bug was located.
The difference here was budget.
the budget for allowing a single engineer to deep dive on a bug that is annoying but also not bad enough that you can live with it for years is pretty big. $10k a month or more. My budget for Claude is $200/mo.
Why are you assuming letting Fable run wild and find the cause here cost under $200?
1 reply →
You have a serious engineering problem if you're not able to find the source of a crash after years.
If it’s rare and the impact is low, then it’s not getting prioritized. It doesn’t matter how much time passes if you decide not to spend time investigating.
You are either seriously naive, or have never worked on any large and complex legacy codebase.
I’ve been living in a bubble with my .NET day-job, where debugging/tracing/postmortems are a breeze. Compare with, say, a CORBA or DCOM system, deployed to prod with uber-optimized binaries without any debugging-symbols.
So it’s not that I haven’t worked on large-scale, complex legacy systems - but that I haven’t worked on any large-scale, complex legacy systems written in languages bereft of runtime reflection and verbose error reporting.
—————
It’s also possible that the bug was never found because its impact was so minimal: e.g. 1 crash per year, each causing 3 minutes’ downtime in a noncritical system: that’s something that will never get investigated fully.
My experience with such problems, is that they stay for this long because nobody cares, not because it's impossible, or even technically too difficult. So hopefully, LLM will improve things, but that quote is a lie.
That kind of one shot capability is impressive but how does it work for my typical work style? The way I work is to build a huge roadmap with goals and hand it to my agent to execute (often over night). I don't care that much about the benchmarks, what I care about is how often Fable 5.1 is making a baffling decision and destroys my plan, not respecting stop conditions or goals. I would seek for behavioral reliability over long autonomous runs, not eval scores. Anyone have that kind of feedback and observations?
Oh you sweet summer child.
Vibe coded slop is filled to the brim with bugs.
If only!
I think we'll have lots of bugs. They'll just be found and closed way sooner. You'll have an agent that watchs for issues, then opens a PR fixing it.
I sometimes have that feeling too, then ask another LLM to do a code and vulnerability review and OMG: rookie mistakes, over complications and security gaps even a 1st year student would not make regularly.
So.. one more year of untreated bipolar AI psychosis I guess..
At least we are at a point where we can have AI review code and reliably find real problems. That alone is incredibly valuable.
I think these kinds of comments really need to say which LLM that is. There's an enormous difference in skill between the frontier ones and say the Google search AI.
Codex Luna, Terra and Sol. Claude Opus, Sonnet and sometime Fable.
They all work, they all are "good", they all are both "smart" and commit incredible basic mistakes a fair amount of times.
Then there's the cost situation..
We will have more bugs. Even the best models with the best software engineers will produce bugs. There are two reasons : first the pressure to produce more and second LLMs will always produce slop
>> LLMs will always produce slop
Such a low-quality comment
> Say what you will about LLM-generated code, but stories like this give me hope that software will never be as buggy as it once was.
Stories like these is what I now call 'Marketing slop'