Now the simple knowledge that there might be an exploitable memory issue in some given piece of software is enough for bad actors to point LLMs at it and find the issue in hours. That will only keep getting worse.

At some point, it's going to become a speed game. If you find a vuln, you might as well disclose to everyone immediately. Anyone who runs internet-exposed software will need an agent watching for disclosures around the clock and triaging them automatically (either by upgrading, improving filtering with some protective shell, or taking the whole service offline until humans can help) to keep up with the offensive agents watching around the clock and attacking automatically.

Yeah I don't buy it either. Look at github right now, it is a total slopfest with people vibing projects they don't know the first thing about. Plenty of LLM use will be delivering code full of new exploits. It will be interesting to see the frequency of these exploits being found correlated to LLM friendly/unfriendly contribution policies once the dust has settled to tell for certain though.

I wonder if we start to hit a point where the pace that exploits are found and deployed increases faster than they get repaired, because there is a natural higher risk appetite for the bad actors, whereas the good actors still require careful thought and prudence. As a result of this, would the internet/digital economy largely seize up and crash? That would be bad, especially for a lot of people on this site. Maybe this leads to a regression in convenience, but requires more in-person interaction in order to function in society. You can already see this pattern today emerging in higher education. Maybe, in a deeper way, this improves humanity?

Only for projects that are in a maintenance state. New features will produce new bugs, unless everyone pays for the tokens to scan every release with the top-of-the-line agents or otherwise spends more time than many do ATM to ensure that changes and new code don't introduce significant exploit paths. Things will slow down once the low-hanging fruit from the past is mostly detected and pulled, but the level of vigilance will always have to be at least a little higher than it has been until recently.

Time between updates releasing and people installing them has been an increasing problem for some time, we are just going to have to be a lot more disciplined about that. This will be a problem for places that have strict availability requirements as they might have to compromise on the testing time they spend on new patches before updating their installations, and we might have to move to having more flexible maintenance windows (the old “an hour or two once a month after Patch Tuesday” hasn't cut it for some time and certainly won't going forward) to allow faster updates.

The bigger problem, compared to the patch-availability-to-general-use time which can be reduced somewhat via automation (though that might accelerate bad-patch based attacks…), is greater constraints for the time between bug discovery and patch release: as soon as there is a rumour of an issue many will start scanning for it (as that is easier now) so the time to wide exploitation is going to be much shorter. This might lead to buggy patches that add new issues of their own.

Perhaps we'll see a lot more projects having explicit LTS releases that only get security updates or signifiant bug fixes, which will reduce the attack surface area (and fault surface area) most users, letting those with less stability concerns deal with the bleeding edge.

> For people like me, this is just yet one more way LLMs are making my life materially worse.

I'm with you there…

1. many have underinvested in security for a long time

2. many are checking out of the development process

I generally think we can improve software with Ai tools, but I'm skeptical the current incentives will lead to this.

It's called job security :)

The time to exploit is also somewhat hypothetical. We're assuming infinite attacker resources which hasn't really been the assumption.

We see a lot more news and fear but are we seeing more actual "large scale exploitation"?

I'd love to see some numbers in that regard.

AI skynet is killing humans. We know that already though.

The slowest that will ever be.

> second that there is a much shorter window between discovery and large-scale exploitation.

The longest that will ever be.

Aren’t exponentials beautiful?

My experience with AI-code is that it's extremely defensive and good at minimizing 'obvious' mistakes.

Are we comparing to old models generating code? Or mythos-class models?

(What a wonderful new world we live in)

Feels like you should be able to prompt the kind of exploits you want to prevent and the model should be able to make the system secured against them, no?

I think this was true in the past but AI is helping us finding exploits which have been in our code for many years. All out there by humans. We’re seeing fewer customer reported issues, and despite the pen tests getting far more rigorous, we’re passing all of them. Obviously this is one data point, but I’m hearing similar things from my friends in security and ops.

Most the cyber security people I know were upset once llms came out that could do basic os int and author their own emails, and mimic speech/video. That's how the majority of real losses occur. No one even talks about it. It's mind numbing hearing about the zebras and unicorns when there are 10 billion ants entering houses a year. Exotic stuff sells...

Now lots of sane people are genuinely and correctly worried that turning all engineers into 24/7 sloppers is and will continue to make the world far more exploitable. That's the real risk as far as I can tell

and vaccines notoriously cause autism. But you might investigate why that belief is so widespread and you might not believe it that much anymore.

Can you point at something specifically that indicates this statement is true?

This seems incongruent with what we're witnessing. Right now we're witnessing vulnerabilities that are 6 years old be exposed. That code wasn't generated by AI slop.

Security has always been about attacker/defender symmetry. So if the attacker has an LLM so does the defender. Reality is, the tax is getting higher as security tooling extracts more perceived value.

Not only this, a significant number of developers have stopped looking at code, trusting the bots. I've seen major security regressions, bot rolled auth implementations, and falsified benchmarks... just this last week, all in projects that get hyped.

Rule #2 - do not blindly trust Ai output

https://susam.net/inverse-laws-of-robotics.html

So you're saying it's good at finding exploits but bad at generating code? I can tell you don't know what you're talking about because pretty much all the exploits that are being found were exploits that were enabled by human written code. So let me correct your statement for you:

There are exploits everywhere and we humans have always been bad at writing code without exploits.

There is tons of old software still around you can use your LLM to poke at. You'll see that it was crap too. Software has always sucked, very little of it has been formally verified or built.

I remember accidentally finding buffer overflows in Netware in school but I had no idea what that actually was at the time.

Now imagine you are an inspector. You enter these homes one by one and discover suboptimal electrical wiring, misaligned trimming, nonsensical handle placement, lazy tile jobs, etc.

Is it a problem? Only once it becomes one. There might be 10 things in your house right now that need fixing, but you will probably not become aware of them until they reach a critical point: a leak, a fire, a collapse.

The human body is similar, no? How many ticking health time bombs are you sitting on?

Maybe this is a reminder for you to go get that exam, haha.

Way too many people do the parallel LLM assistance = vibe-coding, opponents call it slop, proponents claim increased productivity. But vibe coding is just one aspect, but to me, analysis is where it shines, at least when quality matters.

We have static analyzers and sanitizers, sometimes fuzzers, which I think are essential to serious development work. Now, I think we can add LLMs to the list.

We blame AI for many evils, like a lack of understanding, code ownership, poor quality output, etc... This is the complete opposite, here the AI is not there to do the thinking for you, instead it says "here look, have your thought about this?", what to do next is up to you, you are in full control of the situation. It also makes development slower instead of faster, again, the opposite of what people claim AI does. But to me, it is the good kind of slow, as in "slow and steady wins the race".

What I’m getting at is that this PHP bug was adorned with marquee lights and sirens and a giant sign saying, “Hey, look here!”

That said, when that code was written 20 years ago they could perhaps be forgiven for this approach to handling OOM. The alternatives apparently come with a pretty decent performance penalty, and culture around memory safety wasn’t as strong then as it is now. But in 2026 there is an argument to be made that exploits are so common and damage potential is so high that we need to take the same mindset that flight control software developers have in their coding standards: some ways of doing things are dangerous enough that simply using them is a defect, even when they work exactly as intended, because they are just too hard to reason about.

And on the positive side, LLMs make remediation much easier too. It took me around 15 minutes and a few dimes worth of DeepSeek tokens to upgrade some gnarly, janky, exploitable PHP 7.x code to the latest fully patched version of 8.3 today. Without LLMs, I would probably have been having a serious discussion about whether we should ditch the app entirely instead.

I think this is a dated mindset with AI in the mix. Not only is AI making it easier to do big-bang rewrites which wouldnt have been done before, it is making working on brownfield codebases more feasible. It is lowering the barrier to entry for non-devs to contribute to codebases. Most software did not stagnate because there wasnt a need to grow it more, it stagnated because the friction and/or cost of change hit a critical mass.

I think we are much too early into the "new era" of software to understand what it looks like tomorrow, especially in terms of what we assume to be true today.

The caveat being that most software never matures. Maybe it's a cynical take, but virtually all software I use regularly is updated at least once a month. Right now, I'm using Chrome, and I see the "Relaunch to update" button waiting for me to press it. I see the arrow on the Ollama icon telling me I have to relaunch it to apply updates. I have Visual Studio Code running next to my browser, and two extensions need to be restarted to apply updates.

But at least somebody is maintaining that software.

This is not the case here, it's an untrusted regex which can be the issue.

The historic embargo system is likely not sustainable and we need a shift in both approach and security posture (ie fully trustless architectures by default). Not only that, but because of the insanely amplified frequency and risk of the 0-days, you generally have to throw the baby out with the bathwater and leave yourself completely vulnerable to supply chain attacks. Because not short-circuiting taking upstream updates leaves you open to attack.

Theres shades of the old normal in this stuff, but absolutely this is the dial being turned up to 11 and I dont know if theres any right answers for small teams out there.

That's not sage advice. That's just biased, reactionary rhetoric. PHP is just as good or bad as anything else, and it's often the best tool for the job. As with any other language, it can be implemented correctly or incorrectly.

The PHP runtime has had very little vulnerabilities. Much less than Node.

I know there is some kind of mathematical proof that can be done to show the correctness of some software, but is that universally applicable or only in certain situations?

Would love to hear opinions on this from some one more knowledgeable in this area, as the “finite number of bugs” is a statement I’ve heard a lot lately and I’m not sure if it’s actually justified or not

The response was overblown, but your dismissive reaction is too far in the other direction.

I don’t know if this necessarily follows. I repeatedly see that AI will write code, then you have it audit the code for security vulnerabilities, and it still finds them. Just because AI can find bugs doesn’t mean it will write bug-free code. AI’s know how to take shortcuts to achieve their goals, and do it all the time.

Yes, you can have another AI audit the first AI’s code, but in practice this doesn’t always happen, especially because once the human gets their hands on the finished product, they don’t always take the extra step to ensure it’s audited. This is particularly true because people seem to think “well the AI wrote it in the first place, why would it find its own bugs?”, ignoring that context is everything, and an AI being asked to find bugs is going to approach the code a lot differently than an AI tasked with adding features.

That’s not to say it’s not possible to set things up properly into multi-agent stages with QA and security as first-class phases of development… I only mean to say that it’s not automatically true that “AI can find bugs” implies “AI doesn’t produce bugs”.

I wouldn't challenge fate like this.

> > The NHS approach: close source everything.

> Yeah good luck. I've seen how these systems work at decompiling and I expect they're probably going to be really good at fuzzing too.

Me too. The agents are much faster if it has access to source. NHS would have been easy hunting grounds. Now at least they don't stand out.

"a system should be secure, even if everything about the system—except the key—is public knowledge"

Should indeed, but we've all been caught with our pants down.

But I agree it is doubtful that there is still such an advantage...