> 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.
Wow, I feel this deeply. I work with bad software. It is bad because people built it using tools that were designed to "make coding easier". I feel a cold chill imagining the level of institutional cruft that could be allowed to build up with unrestrained ai coding.
With that said - the process of fixing those old mistakes is greatly aided by llms... but you still need to understand what you are fixing, and understanding why giant blocks of code are copy-pasted everywhere, or why convoluted hacks evolved over time as reactions to bizarre underlying untreated bugs is, imo, ultimately a human/organizational/processes problem.
There's a minimum threshold of knowing what you don't know that's needed I think.
Below that the AI will need to get good enough to compensate for people's lack of knowledge. But that will cost money so not sure how it's going to be balanced.
I have friends codebases where I had them just run a stupid simple prompt like "spawn subagents to find the top 5 worst issues in this codebase".
Wide open APIs allowing anyone to modify the database and charge customers among other things. The mere awareness of needing to secure things is lacking from most vibe coders.
> Good software will be good-er. Bad software will be nightmare fuel.
We are talking about a moving target here ... they get better every few months, so I expect the super-LLMs from 2035 will write amazing code even with sloppy prompting.
Software engineering has been a thing for decades and you'd still be hard pressed to find two engineers agreeing on what constitutes "good code". It's not a serious discipline, we're closer to bootleggers brewing liquor in a bathtub than we are from anything remotely close to engineers.
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, as in stateless programs, doesn't actually matter and never did. They can be replaced trivially.
The problem is the real world isn't made of stateless programs, but lots of important data in bespoke formats/schemas, and if you change the shitty software that interacts with the important data, in the wrong way, you can lose everything.
Translation: As the number of bugs per line of code is a constant depending on language and project, we will experience a world full of bugs now that LLMs generate so much more code. On the other hand, LLMs are so quick at fixing them, the number of bugs should go down.
I wonder which trend will be winning though. I personally won't bet on quality.
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.
Nope. The difference here is stamina. Those models never tire while working on an issue, people do.
And I doubt finding that bug cost more than $1k or so. Even if $10k. Thats nothing for a large department in a multinational company. Thats maybe 2 weeks of fully loaded costs of an engineer. Thats a single business trip across the Atlantic. Thats about two company issued macbooks, or one, if the company is nice. Nope. Not budget.
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?
You can engineer loops that have it, but it depends on a case by case basis. Does your loop have strong validation? if it's all vibes nothing can stop it from diverging.
Agree on the validation, my loops are already gated. My concerns are about the cases when model is passing validation and quietly abandoning the goal. The second scenario is rewriting the plan to fit what was already done.
I use Kimi K3 and GLM 5.3 to find old bugs and improve old code, and would try Fable 5.1 if I could afford $50 for 1M output tokens (I am retired and all my research is self funded now)
I like to start by prompting with “examine this code base for problems and improvements and write to IMPROVEMENTS.MD” and then carefully look over the suggestions, and either fix myself or let the model+coding harness try.
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..
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.
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.
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.
Sorry but I don't buy it, any crash can be found and fix by one or more humans, if it was not it's either they're incompetent ( I doubt that ) or they did not beleive it was important enough to fix.
A crash is actually the easiest kind of problem to fix since you have a crash. It means stacktrace, core dump, kernel error etc..
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.
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
What are your arguments then ? What are your thoughts ? I use fable everyday and it is always coming up with changes on thousands of files for simple things, overall the code does the job but there is always marginal slop or unnecessary code to be addressed.
To be more concrete, the last two examples were that Fable added every time a function called utcnow in newly added Python modules, and it always ended up adding constants. I'm saying it takes a lot of effort to make sure Fable or other frontier models don't produce such marginal slop and to keep things concise.
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.