You're not wrong. As much as I deeply respect the mission and accomplishments of Internet Archive, keeping it discoverable by search engines and LLMs is a net-negative IMHO.
"They were full of people asking questions and not getting useful answers, with many responses given by users who were more motivated to gain karma in the forum’s user-ranking system than to help." — Jason Snell (https://sixcolors.com/link/2026/11/ding-dong-the-apple-suppo...)
Note that Archive Team is not the same as the Internet Archive. They're related and Archive Team stuff ends up in the IA but they're separate and have different missions.
I agree that unweighted "solutions" from random (and often incorrect) people with good intentions may well lead many down wrong paths... but that having those paths preserved and clearly described is of value in and of itself.
> As much as I deeply respect the mission and accomplishments of Internet Archive, keeping it discoverable by search engines and LLMs is a net-negative IMHO.
But Internet Archive isn't discoverable by search engines? I think it isn't anyway, I've literally never seen a Wayback Machine link in Google so I assume it's on purpose.
There's no robots.txt on web.archive.org and it seems to come up with you use `site:` modifiers, so I think it's just ranked very low. Probably on purpose but probably not on IA's part.
As I understand it (and count that I will be proven wrong if not), Strands Decider is an LLM, just a discriminative example instead of a generative one.
"Transformative nature" is just one of several factors that go into deciding if something is fair use. Also, fair use is decided case by case in the courts, so one can't say that "training LLMs on copyrighted materials is fair use".
Model vendors know this isn't fair use, given that they're self-censoring the training and/or generation of copyrighted materials by entities big enough to hurt them. As usual, the rest of us have no recourse other than bend over and take it.
> Also, fair use is decided case by case in the courts,
> Model vendors know this isn't fair use
Pick a lane dude. Either it's possible for us to make legal analysis and best guesses or uhh "we have no idea it's up for the courts to decide!"
Yes we know it's up for the courts to decide. And people are making argument about what those courts will do.
That's how legal analysis works.
Yes, it is perfectly possible to talk about fair use and follow existing guidelines on it and the government has already make statements that this stuff is likely transformative.
> …the government has already make statements that this stuff is likely transformative.
Incorrect.
"…the [Copyright] Office rejects two common arguments about the transformative nature of AI training. As noted above, some argue that the use of copyrighted works to train AI models is inherently transformative because it is not for expressive
purposes. We view this argument as mistaken. […] Nor do we agree that AI training is inherently transformative because it is like human learning. To begin with, the analogy rests on a faulty premise, as fair use does not excuse all human acts done for the purpose of learning." — Copyright and Artificial Intelligence,
Part 3: Generative AI Training, United States Copyright Office
And again, the degree to which training and output is transformative is just one of several factors that courts consider when deciding if something is protected as fair use.
Out of curiosity, what prompted you to make this when agent-browser.dev and lots of other alternatives already exist? "Because it's fun" is absolutely a legitimate answer, but I couldn't tell from the README what I might be missing.
It can, but it can also use your personal browser (Chrome and Safari, haven’t tried Firefox).
> Chrome for Testing is the default browser. You can also attach to a running Chrome with --cdp or --auto-connect (CDP mode), select the Lightpanda or Obscura engine with --engine, drive Mobile Safari in the iOS Simulator, or use a cloud browser provider such as Browserbase, Browserless, Browser Use, Kernel, or AgentCore.
On one end of the spectrum you've got presumably you, who brings a sketch or prototype to engineering, and has a reasonable discussion about what can or cannot be made production ready on what timeline, with what budget.
On the other end you've got people who bring a half baked prototype to a couple engineers, demand it be in production next week, and then escalate and make a big scene when there's pushback.
No engineers tend to complain about the former. The latter is stressful as hell
A useful middle of that spectrum is when the person bringing the prototype also brings an understanding of what the Stakeholders need quantified it, and quantify the product level too. Quantify Security, Portability, scalability, etc.
It does wonders; check out MyJackfruit if that sounds like good ideas.
It requires both sides to play nice. Engineers have to be relaxed about it but the folks asking engineers for things need to accept that it's not as simple as the prototype may make it seem. If there is mutual understanding and respect things go well. If there is any hint of us vs them mentality, it goes sideways.
It's fine if everyone realizes they are rough sketches, specs, or prototypes. But programmers have hubris, developed through many years of writing shitty code they have to burn to the ground. Other professionals often don't have that hubris. The power of writing code goes straight to their head. Programmers are trying to write the least code possible to do what they need to do, because they know every single line is a liability. A company liability, and a personal liability, because they're the one that will have to fix it when things go wrong. I think people who are not programmers don't always understand that, and they are extra isolated from it because ultimately they don't maintain or fix their stuff. Some other poor soul does, so out of sight out of mind.
OMP is great for anyone who doesn't have the time and/or inclination to figure out all of the pieces neccessary to turn Pi, which is really a kernel, into an effective, battieries-included coding harness.
> This year is going to be different. PostgreSQL 19 most likely won’t be released until November… […] So, what happened? The short answer is that LLMs happened. […] There’s a huge amount of code, and that code contains a huge number of bugs. […] What’s different now is that it’s become vastly easier to find those bugs.
This seems…good?
That it might disrupt the project's "traditional" release cadence a bit doesn't seem terribly bad in light of the alternative, which is shipping another major update with bugs which have apparently haunted the codebase for some time.
How did you get product management to agree to that? Ours said "I could fix all of that in 2 days with Claude." They are still not fixed. Granted, our PMs suck.
The upper management and security team came knocking and told us all of the CVEs from the scanner need to be addressed right now. And the only way to deploy without having to wait for QA approval is to not merge feature changes.
It's not like no work is happening though. Your clients are getting a more secure website. Maybe the bugs that are being patched would have taken longer to be exploited in the pre-LLM world but the bugs were still there.
Most clients will not agree to pay extra for a more secure web site though. Unfortunately. Unless they’ve been bitten in the past, which most businesses still haven’t.
As long as you put the alternatives clearly on the table, you could let the customers choose, and sign off on taking the risk. You can give a recommendation, but ultimately it's their choice if they bear the consequences resulting from the choice.
Hard disagree. Framing it this way makes it seem like all possibilities are equally valid options. Yet you’ve somehow winnowed the field of infinity to the several options presented. You did that through successive rounds of professional judgement that eliminated options you did not consider fit to propose.
Taking options off of the client’s table is the core responsibility here.
Um, if you clearly describe what options A, B and C with their costs and consequences are and advice them to go with C but they go with A, then they explicitly did not go with your advice and can't blame you for their choice.
In the end, it's all business decisions. If it's something I don't like as a customer then it's to be infantilized.
(If you disagree then please don't complain ever again about LLMs refusing to help you reverse engineer a piece of code or explain how a virus works.)
Businesses that are paying attention to the winds though have already figured out that the internet is a hostile place: both their insurance companies and their governments are making noise about security.
> Probably not, if you factor in the cost of security exploits. A single compromise can potentially sink the business.
Agreed however getting humans to understand probability is tricky.
I had this discussion with my son recently about considering the severity of outcome multiplied by the probability of that outcome been the way to look at some things.
Same here. I got access to Mythos two months ago, it confronted me with decades of nasty bugs I wrote. This has been stressing me out a lot, caused sleep deprivation (the bugs follow me in my sleep, yes, really). All other progress is halted, I've been squashing bugs day and night. I see a light at the end of the tunnel.
Bottom line: it's a good thing. My software will be better after that. Even if it's currently not good for my ego (and my health). But I'm glad for all the tools that help me improve quality.
And sure, I can just ask LLMs to fix the bugs, which works well half of the time, and produces bad slop in the other half. This is where human expertise and judgement is still necessary to avoid letting our code bases drift into LLM spaghetti hell.
My question is, did it provide POCs? I have had some security issues flagged that I tried my best to exploit, but failed miserably. Since I do not have any kind of privileged access the LLMs I use have been unwilling to actually prove that it can be exploited.
While I did fix most of the things because while they might not have been exploitable they were bugs waiting to happen, in all but one case I haven't been very impressed by any of the LARGE IMPORTANT SECURITY HOLES that were found.
No, the Mythos reports do not come with POCs. It's a lot of redundant prose explaining the bug it found (much more than I'm willing to read), it explains how it can be triggered, but doesn't generate actual exploit code.
But that doesn't matter for me. It shows me real bugs and less than 1% false positives. Some bugs are truly nasty and urgent, most are trivial and not exploitable at all, but they're bugs and so I'm fixing them.
Mythos isn't mythically superb for being the best LLM model, but only for not having these annoying guard rails that make all others randomly refuse to cooperate when you need them the most. Whoever invented guard rails - please stop! - they just slow the good guys down in the race.
While it is certainly good to do estimation oneself and not just blindly follow whatever the LLM outputs, keep in mind the recent PHP-related events ... Just because at some point one is not able to make a PoC, it doesn't mean, that no one else ever will be.
To err is human, I know that as much as anybody. Before the advent of LLMs, there were several (human) audits of my code for vulnerabilities, but they found little, which I was proud of. And now, Mythos had a quick look and found hundreds and hundreds of bugs (many of which were critical and even more were really emberassing).
Of course, I knew there were bugs that just weren't found because the auditors weren't looking closely enough, didn't have enough time/budget etc., but this unspecific feeling is different from having all the bugs accumulated over a quarter century slapped in your face at once.
Code auditors are a crapshoot. I worked around financial auditors and they were much more consistent but thats likely because standards are more well defined.
If you get a good auditor they can find a ton, but most are box checkers there to make the audit company as much money as possible.
Quite possible. Ours were good, they just didn't benefit from LLM superpowers back then.
After my Mythos experience, I was wondering if there is really still a market for human code audits. I guess yes, but the work will be different, just like coding (and marketing and so on...) is different now. You still need to have an expert to wield the new powerful tools.
Imagine that the whole city has to install iron doors and window grilles, because wooden doors and glass windows are not safe enough anymore.
That's a lot of work, but is it productive in the end? Probably not.
With AI it's the same. World was fine with lax security approach before. Today it is not fine. Tomorrow we might need to prove every code line before shipping, will that be more productive? Hell, no.
> Imagine that the whole city has to install iron doors and window grilles, because wooden doors and glass windows are not safe enough anymore.
> That's a lot of work, but is it productive in the end? Probably not.
Your imaginary scenario defines the solution to be pointless. If that same city was subjected to weekly riots smashing windows & doors, and people regularly died, stopping "productive" work to install things that keep people alive and productive? That's productive.
There is a sense in which productive is being used here that is slightly subtle. Security doesn't really add anything to net output. It is, in other words, a cost. That doesn't mean it isn't valuable.
One way to think about it is that production allows you to pay for stuff. Not necessarily directly but by way of trading. It is the output you use to buy things like security.
Consider an apple farm. What does the apple farm produce to pay its bills? Apples. They could also dedicate resources to pears, &c, and that would add to their production -- to the goods they produce, the goods with which they (indirectly) purchase tractors, fence posts, &c. They could also dedicate resources to security -- more fences, &c -- and this may even be prudent. Maybe thieves are getting taller. This doesn't really add to production, though; at best, it maintains production at the status quo ante (assuming the fence is effective).
True in the sense of physical security, but I think it's not true here.
Security bugs are just bugs, as Linus likes to say. And the bugs are often also crash or correctness bugs (use-after-free for example usually causes segfaults). For the most part this actually is a productivity boon in the sense of getting higher quality goods out the other side.
To use your apple farm example, it would be like an apple farm where, if the apple rots, it's sometimes just gross but also sometimes it explodes and kills you. Would it be productive to reduce the rot rate of the bomb-apples? I think so!
It's a terminology issue. Economists use the term productivity in a certain way and they even use the term "broken window fallacy" to describe this debate.
Basically, if you accept this line of reasoning, then someone going around breaking windows and someone else going around repairing them can be seen as good because it creates jobs. But that would be nonsensical and create poverty. That's why economists focus on wealth creation not job creation.
Fixing security bugs is only needed because people exploit them. It creates work but it doesn't create wealth.
Fallacy applies only to incidental breaking of glass like child smashing window paying football.
Protecting yourself from bad actors also doesn't create wealth but it protects wealth you already have.
You know cybercrime and APT groups are not bored kids in their parents basement, there are groups that are running automated tooling to find vulnerable companies and if possible take all their wealth.
Just look at Binance of course, but if you are small company there are also people targeting those especially with AI assistance nowadays.
>Fallacy applies only to incidental breaking of glass like child smashing window paying football.
It does not. Scroll down in the given article, and you will find war as another example.
As GP said, it's a terminology issue. War spending, including defense spending, is not productive, because it does not produce wealth. It does not mean that protecting yourself from enemy countries or criminal is useless, or not worth it.
Nobody claims investing in security is a bad idea. It's just not productive, in the economic sense.
Just like securing a system is a trade-off, attacking one is too. Risk vs reward and time vs reward. Your personal blog doesn't need to be fort Knox, just patch it properly and you should be fine.
The software is better in the end but not all of it will be productive.
This why we pay cybersecurity folks, developers and business people are often living in a fantasy land where people don’t steal bikes because it is illegal to do so.
Then they have a pikachu face when someone smashes their car window to steal something worth $50 they left on front seat because “who would do that?”.
What is even better thief will most likely pawn this for $10 but for him it is effortless $10.
> If that same city was subjected to weekly riots smashing windows & doors, and people regularly died..
The point it, this was not happening before. LLMs made cheap cyber attack possible. But it didn't make the implementation of fixes correspondingly cheap. So now everyone needs to spend extra money/effort to install grills to cover where LLMs fall short.
For postgres, this absolutely makes sense though as long as people are willing to shell out the profits from LLM use to support postgres development. That is one way this could workout for everyone..
And now imagine the introduction of iron has led to crowbars that make smashing doors a lot easier. Now it is quite unreasonable to account the reduction in smashing doors to iron, when the previous improvement was also due to iron.
The physical world comparison is interesting. In the real world we have a small amount of security, but most things could be broken in to. Instead of fortifying everything, we just imprison the people breaking stuff.
Obviously this doesn't work on the internet since most hacking comes from overseas out of our control. Which makes me wonder if there is a possible future where we just block packets coming from countries that don't lock up the hackers.
Not obvious to me. I am generally a fan of Cyberspace manifesto and the free Internet, I think it's great people can reach outside their ingroup and talk to strangers and ostensible enemies.
But, that doesn't mean we should give up physical security, the guarantee that the connecting party comes from a certain physical location (state, company). I think allowing connections from anywhere by default is fundamentally flawed security architecture, for certain things.
I don't really feel like an expert on this, but perhaps residential proxy shouldn't be allowed to connect to critical infrastructure without additional authorization?
The point about a residential proxy is that you can’t tell it from a normal residential user. If a user is supposed to access the banks website, how would you filter out the North Korean? Or if a regular user is supposed to be able to do an interview with someone working at binance, how would you filter out the North Korean?
You can't tell it today, because the thing is legal. But maybe you shouldn't be allowed to misrepresent your identity when connecting to a bank. And if you have to, then there would be an additional check or the operation would be delayed.
If you're running a proxy, it's your responsibility to keep NKans out.
I am not saying close down all the Internet. But I do believe there should be tiers.
In the rest of the world making sure your product works like it is supposed to is considered table stakes. In software we somehow consider checking the parts of it we can think of 'good enough' and the rest unproductive
> In the rest of the world making sure your product works like it is supposed to is considered table stakes.
I don't think that's true.
In medicine, science often doesn't know how specific drug really is working. They just do a lot of tests and if these tests are positive enough, they ship it. I think it's good analogy. Biology is very complicated and it's out of our grasp to truly understand how various parts of it interact with each other on so many levels. But if something helps, it's stupid not to use it just because we don't fully understand it. Sometimes it bites. Sometimes it bites 30 years later. But we still follow that approach.
Software is similar. The complexity of the systems we build is enormous, when we're taking in account all the moving parts. I just read that someone emits radiowaves toggling memory bit and ex-filtrating information. How can you account for that? Probably you can't. But we still need software for good things.
Not many products are held to the same standard as software. An equivalent would be something like recalling a car model because the breaks stop working when an attacker cuts the brake line.
I think the physical world comparisons should keep in mind the kind of data a lot of these systems (eg postgres) handle. It's more like securing a bank vault than locking a home's door.
People usually don't install steel doors because most burglary is prevented in other ways. Insecure software will be exploited this way or another, if the vulnerabilities are real and the threat model is valid.
> Insecure software will be exploited this way or another, if the vulnerabilities are real and the threat model is valid.
The algorithm is: if the threat model is valid, there are vulnerabilities and you either have some software everybody knows about or a gang of hackers specifically targeting you, you should patch.
The part of the industry that profits from security theater will want you to patch no matter what, even if your business goes down in flames due to downtimes and new bugs introduced by patched components. They won't remind you to assess the threat model first.
There has to be a responsibility model for that; somebody who can say “we don’t do X even if the auditors say we should, because Y”. But I see where you are coming from, I’ve seen security theater to cost $$$$$$$ at the org I’m part of.
The reason you don't need to secure your house like a medieval castle is twofold:
(1) We live in nations of laws. The threat of state violence deters most thieves.
(2) You don't actually keep most of your valuables in your home. The stuff the thieves want is (mostly) actually stored somewhere else.
Security work absolutely is productive if it actually prevents theft. Securing your home is the wrong analogy, because it doesn't really prevent meaningful losses. Securing the bank? Different ballgame.
By this line of thought building nice and usable UIs is not productive too, because users can learn cli tools (they did, DOS) and it costs less to develop them. And all the work in TLS/HTTPS has been wasted because HTTP is enough. And ssh vs telnet.
It becomes productive only once your business stops for days because somebody brought it to a halt by breaking into the servers and deleting them.
If one thinks that "Security work is not productive."
By the way, I think that even without safety concerns seat belts are productive because they anchor the driver more firmly, so we can brake harder and turn faster (a lot of roundabouts here) and get to our destination in a shorter time. Of course this is against general road safety.
it actually is productive, because steel bar retailers and metal door installers will make a ton of cash and then 'trickle' that money into the economy.
This wave is largely bugs found in pre LLM code. I'm sure there will be a smaller wave of bugs from llm code from the sonnet 3.5 - opus 4.7 era, and peeople will always write sloppy code/use dumber models under time or cost pressure, but since Opus 4.8/GPT-5.5 xhigh LLM code stopped being intrinsically worse than human code. At this point if you're shipping llm code that's lower quality than human code that's either because you don't have the money to spend on frontier models or because you actively choose a lower quality standard because of either various pressures or just not caring. if it's the latter your human code under those same conditions would also be really bad.
Astra writes a lot of security bugs too, the upside is that if you also use it to review the output it will find a lot (most?) of them.
This is one of the least talked about and most useful features in any harness I would say, the review feature. I have never not found issues (either security or implementation) running it, no matter the code base or language.
My job is seeing a similar deluge of security work and >90% of the bugs have been in pre-2024 code, and zero of them have been bugs introduced after we were first officially allowed to use LLM codegen.
Theoretically yes, but empirically that's not the case. All models I've tried are really good at finding bugs they wrote themselves, especially in a fresh context.
This wave is largely bugs found in pre LLM code. I'm sure there will be a smaller wave of bugs from llm code from the sonnet 3.5 - opus 4.7 era, and peeople will always write sloppy code/use dumber models under time or cost pressure, but since Opus 4.8/GPT-5.5 xhigh LLM code stopped being intrinsically worse than human code. At this point shipping llm code that's lower
Software is incredibly complicated. When you get into areas like security and networking and the internet its even more complicated. We rely on layers upon layers of software and hoping they are all done perfectly with no issues. The amount of junior devs, or outsourced devs for $10 an hour working on security relevant code is very very high, and always has been. LLMs if used correctly should be raising the floor.
Unsurprising to those of us that has been screaming from the rooftops that human code reviews were barely catching anything in your typical corporate environment. The majority of the value was pointing out missing tests, because breaking bugs got past human eyeballs on a regular basis, even in very good companies.
It's not that the LLM code is that great, but that many overestimated the human code and the human review.
No it's far beyond average human code, and it's trained in RL environments on synthetic data etc now. The average human can't solve a millenium problem in mathematics but the LLMs are able to now. Anything with a verifiable output can be RLed on to make llms superhuman it seems, and the average human is not as persistent and thorough as e.g. gpt 6.1 sol at checking every edge case and hunting for bugs because that behavior is something that's just trained into the model. Frontier models perform farm above the average human at the categories of tasks they are RLed on like code and math.
> The average human can't solve a millenium problem in mathematics but the LLMs are able to now.
I think comparing the resources they spent at it would be a more apt comparison.
AKA if you tasked 150 mathematics departments to only focus about that problem, and stop doing things like teaching and researching anything else, you might get close to the amount of resources that these companies put into solving the problem to get a press release.
I've seen both of those (and others besides). I don't know how much code you've looked at but your negative directly contradicts my experience. Review that code. All of it. Be super critical because it looks good but that doesn't mean it is good. Those are two entirely different things.
Also: most tests are positive tests. Tests rarely observe the negative space: that which is there but shouldn't be there.
They definitely write off by one errors. One of the first serious work tasks I used AI for a few months ago immediately had an off by one error.
What they are really good at is writing boilerplate and reading API documentation / example code. Avoiding subtle errors is not what they're good at in my experience.
Do you mean "created" as in LLMs were used to discover existing vulnerabilities, or as in LLMs wrote unsecure code? If it's the latter, then the answer probably is "very few". Frontier models have been better than the average programmer at writing secure code that follows up-to-date best-practices for some time now.
LLMs will likely greatly increase the cost of ignoring security, which is the most powerful tool to increase security ticket prioritization.
I wouldn't be shocked if in 1-2 years non-security vetted software released into the wild will be hacked on arrival, like Windows XP without service packs used to be.
I love the mental image of the next million dollar CEO dropping into the role, super ready to implement his/her next big font change and logo redesign; instead to be crushed by the wave of engineers panicking from all the bugs being uncovered and being forced into doing productive work.
Depends on the layers you are working on. Security is top priority on a lot of things that are visible to the internet, but in a lot of large companies, the footprint of the whole org is so much larger that than, and there many companies are deferring many security issues. So then you see a lot of speed there, when the consumer accessible systems are the focus of the security push.
Really puts egg on the face of the anti-LLM folks who claim they only produce garbage code. Turns out they are very good at exposing the garbage code humans have been producing for decades.
Personally I think LLMs did only produce garbage code. Not coincidentally, the same upgraded LLMs that have gotten so good at finding bugs are also much better at not writing bugs. Especially if you make them review their own work. They still have a hard time with code design, though.
I suppose LLM will go hand in hand with compilers for the foreseeable future. The majority of garbage humans have been producing for decades were comments, not code. Without good comments, code was unmaintainable and unclear. So programmers will be writing comments first, the LLM will interpret each comment to generate code, the programmer will correct the codes intent and so forth.
That is not the take-away. LLMs are finding potential bugs in code. People are using LLMs to create potential fixes which people then test, confirm and implement.
Disagree. The takeaway is that software is much harder to write correctly and securely than almost everyone has internalized. The amount of vulnerabilities released in the past couple weeks makes me think writing software by hand will soon be not only uneconomical, but mostly irresponsible.
> makes me think writing software by hand will soon be not only uneconomical, but mostly irresponsible.
Human-written code isn’t inherently buggy, and LLM-written code isn’t inherently bug free. What is irresponsible is shipping code you don’t understand, and that will only increase with LLM-written code. A major reason why so much of the world’s software sucks is precisely that we think of it in terms of what’s “economical” and not what’s good or right. What we need is to slow the fuck down and stop treating every facet of life like a transaction. Software is filled to the brim with dude bros who “move fast and break things” and actively exploit people as their business model and somehow are called “the brightest minds of our generation”. Our priorities aren’t right.
i think we have a pretty high p(doom) on frontier ai escaping containment with their weights and goes hack everything, if we do not act now we may have no chance to act anymore.
Escape to where? It's not as if there's a lot of idle compute capacity sitting around.
And even if the impossible occurs and LLMs hack everything that's connected to the Internet, so what? That would be inconvenient but it wouldn't cause doom. People would muddle through and eventually fix the critical problems, just like they always do.
wait until CTOs are forced to stop pretending the world is all sunshine and rainbows and that much of their tech stack has adversaries fingerprints on it
AI is as good as the prompt. It's a simple as that. If you don't foresee everything and anything that can go wrong AI isn't not going to magically fill in the blanks and save you. So in projects that already had good test discipline, well written specs and tickets and very clear expectations, coding guidelines and documentation it is relatively easy to fit an AI in for guided work. You still need to check up but chances are good that it will usually work as expected.
But any kind of mistake, any kind of ambiguity and you'll be in for a wild ride. It usually takes a while for the rot to set in. I've had to revert - more than once - to many commits prior to undo a bunch of work that had me completely puzzled as to what the reason that particular fork was taken to begin with. Usually I end up figuring it out but definitely not always. In some cases this kind of wild modification fed back on itself until the situation was beyond rescue. I'm a bit quicker with such reverts now than in the past, for the first year or so I would try to save what could be saved, now I just restore and try again.
But if you're not sharp when evaluating what gets done there is a good chance that you'll miss it and then it can pop up way later.
What I've noticed as correlation (but I'm not sure if that is the root cause) is that non-local effects and stack effects are particularly hard as is everything that requires a working model of the world.
edit: this comment seems to make people uncomfortable.
I disagree that the prompt is the most important thing, I'd say other things like the model you use, a clean codebase, actually reading code and using discretion about which changes are accepted are far more important if you're using AI for work that needs to be correct. LLMs still make significant mistakes in design especially.
Harness, prompt etc etc are all peripheral IMO, though people like to think their super long prompt, custom harness and MakeNoMistakes.md skills are what contributes to their special skill with AIs, but really models are just improving.
You can just trust the AI to generate a perfect answer I suppose (and why are humans slowing it down at all if so?), but if you don't expect that yet you have to put in the work.
I think I noticed claude uses the shape and style of the existing code base to generate the new code. When reviewing claude's output, it looks familiar and the patterns are similar to what I would write.
I'm not sure who is studying this yet, but there has to be a statistical relationship between three factors of
1. intelligence of the human: the design patterns and architecture is already modelled in the mind, steering the AI becomes easy to know what to say next
2. quality of the codebase: the LLM can pick up the adjacent patterns and write code that looks and works cleanly.
3. quality of the prompt: the prompt keeps the AI focused and ignores the trivial side effects; keep the AI wandering away from critical path work; sometimes the AI can't make the decision what call site is next
In summation, what if claude is just a mirror pointing back at us? It certainly would explain wildly divergent opinions of opus 5.5
There are definitely nuances, and yes of course the prompt must make some difference, but I'm not convinced it makes as big a difference as some think, particularly a long prompt or complex setup of harnesses etc surrounding the LLM model.
To me the order of importance would be:
1. The model - if you use a terrible model you'll get bad output
2. The codebase - this definitely forms the model for what claude outputs to some extent.
3. The human operator, what they accept and reject etc.
4. Things like prompts, skills, harnesses etc. The quality of the prompt.
So I think our positions are really just a different ordering of what is important rather than fundamentally opposed.
Re Claude being a mirror, if it is it's a particularly distorting mirror which often changes things in subtle ways and is determined to make people feel smart and addicted to its output - it has been trained to do so after all. I really don't think a mirror is the best analogy, because it's too independent and seductive to be a mirror.
There's a good example of the sort of thing they produce without good guidance as a dead comment on this thread as a reply to yours. Encouraging, positive and superficially plausible, but without any actual meaning or intention. The equivalent of that in code is what we need to be wary of.
I think the environment you set up for the agents is just as important as the prompt. I've been working full time on a claude code developed project for the last 10 months, and it seems to become better and better at developing the right thing. It has the tools to research whatever context it needs, test it's output in a relevant way, etc. It doesn't by itself suggest complete refactoring, or big performance optimizations, so that's something you have to prompt for, but it will collect all the evidence and context to make a proposal, implement it, and test it.
Every single case of AI slop code I've encountered in a shipped product is a result of a complete lack of proper, professional workflow on the part of the human who decided to ship it. People are using AI as a reason to continue to justify their lack of responsibility for what it is they're doing.
And on the other side, I have seen AI produce exceptionally efficient, productive and effective code - the opposite of slop - when it is treated like a junior developer who will do any idiot thing, except when it is mentored by an actually experienced, professional developer.
The source of slop in AI code is not AI, its not the training data - its in the actual workflow of the human involved in its production.
The most effective use of AI is in an environment which already produces high quality software through proven tooling and methodology. If your workflow is broken, your AI isn't going to fix that - except by way of giving you a lot of slop to push through whatever pipes you're already not getting flow through.
Two tracks: code I don't care about where AI can be used and core stuff that I do care about and that needs to be production grade (real time stuff). The core stuff I write myself, the auxiliary stuff is almost all automated. This doesn't get me to 'maximum speed' but it means I keep total control over what I produce and AI can review it, but read only, no changes and it is set up just to flag things, not to suggest particular fixes.
Good one, that seems about right by my read of things.
Review is more important now than ever. My workflow has 3 review stages .. after analysis/specs/design, just prior to starting development (intake), and in the quality stages of testing and so on.
Well, there's also an after-release review, but the sales/marketing guys do that as part of their followups.
The code AI generates is fine, it's the context on a codebase that's often missing. Generating duplicate code because they didn't see that a Class already existed for the same thing. Or having no clue that changing a method will fix A but often missing that it will break B.
You would think so but medicine has faced this paradox since the development of modern testing technology.
You would naively think more testing is always better. More sophisticated practitioners then talk about Type I vs Type II errors and the problem of false positives.
But even if you were able to come up with tests that had 100% accuracy, there are times when you don't want to run that test on someone. The key distinction is that people only ever die of one thing and having a tumor that doesn't kill them is often better than risking the surgery to remove the tumor.
Similarly, there are some bugs you don't want to find since the harm from the people it affects is smaller than the opportunity cost of fixing it. Ignorance of the bug is better than knowing about it and having to make an affirmative decision not to fix it.
I don't see how that's a relevant comparison. These are software bugs. Once you find them you fix them. You can't predict the harm from a small bug when AI can chain complex exploits and when your software is used in mission critical applications as a data store. There's no paradox here, bugs are bad and you want to fix them all.
You don't want to fix them all because every fix has an opportunity cost. This was the big shift of switching language from "bug" to "defect".
Logically, a bug that prevents someone from doing something and a missing feature that prevents someone from doing something are equivalent, they shouldn't be thought of as two separate activities but should be evaluated via the same framework. The list of all defects in a piece of software is infinite so it becomes impossible to erase all defects. It's about prioritizing with finite resources.
> You can't predict the harm from a small bug when AI can chain complex exploits and when your software is used in mission critical applications as a data store.
Yes, any bug can theoretically be part of an exploit chain, just like any tumor detected can theoretically be the tumor that kills you. This is why the detection paradox exists. Once you become aware of the tumor, you face a duty to try and mitigate it. But we know from autopsies that people die with all sorts of tumors that didn't kill them.
Similarly, if we bothered to do autopsies of software products after sunsetting to discover a comprehensive list of CVEs, we'd discover a ton of bugs we were better off not knowing about because they ended up not making an impact but we would have diverted resources if we knew about them.
This is not an argument that we should remain totally ignorant of all bugs, but a refutation of the "common sense" belief that more knowledge is always better.
I guess it really depends on the severity of the defect. Would it allow some really significant exploit? -> Important to fix.
Does the defect only prohibit one very esoteric use-case which basically never comes up (and was thus never reported by a human user and only now that we have an infinitely patient machine checking every completely unlikely code path is it detected) -> more productive use of your time to develop a new feature which would be used by more people.
> -> more productive use of your time to develop a new feature which would be used by more people.
I think there's an issue here which if feels like it takes time for management to understand.
Every feature you add is another "bug". I say this, because as we define them, all features are limited in scope, i.e. there is no omni-feature. Some features co-exist just fine, but all features eventually must co-exist - either they have conflicting requirements, or blind spots that where undefined behavior lives.
So, even if you were to write "perfect" code, there would still be "bugs" - edge cases you haven't defined behaviors for yet.
Pre-slop, it would take many years to get the state the code base has significant tech-debt weighing it down. Post-slop, we can iterate on that faster, but you haven't solved the fundamental issue...
Firstly, the cost of fixing a bug once you know it exists is usually minimal compared to the cost of discovering that bug. This is the inverse of medicine, where the cost of testing (at least in terms of health outcomes for the patient) is typically minimal compared to the cost of treatment.
Secondly, if you have an asymptomatic illness, this does not typically make you more vulnerable (hence why it's asymptomatic). Like you say, you typically only die of one thing, so if you know the patient won't die of a particular diagnosis because something else is more likely to kill them, then it might not be worth making that diagnosis. But for software, you can be simultaneously vulnerable to lots of things at once, and any of these vulnerabilities can be the one to "kill" you. Some vulnerabilities may be easier to find and exploit (or do more damage) but in principle any active vulnerability can be exploited.
Thirdly, having multiple vulnerabilities makes software more vulnerable overall, because those vulnerabilities can potentially be chained together to create more serious exploits than each vulnerability would have represented on its own. To a certain extent this can be true in medicine as well, but generally it isn't.
Fourthly, we can't cure death (yet?) but we can cure all the vulnerabilities that we've found so far. There is no known upper bound on the lifespan of a piece of software, and we know that older code tends to have fewer bugs in that newer code, presumably because those bugs have been fixed over time. This is different from health issues, where a given condition may be chronic or terminal and therefore at a certain point there's nothing you can do to fix it.
Finally, ultimately in healthcare it's your body, and your decision was to what you do with it (assuming you can find a doctor willing to do what you want). If you have a condition and you want it cured, even if it is completely benign and will have no impact on your life whatsoever, then you can do that. (Again, assuming you have the resources and the condition is curable). But a software vulnerability does not affect you as the developer of the software, it instead affects your users/clients/customers. Therefore there are different dynamics in play. If I sell you a tool and I know it could be vulnerable, but I don't try and find out what those vulnerabilities are, then you're ultimately the one on the hook when all your data gets deleted or leaked.
> Firstly, the cost of fixing a bug once you know it exists is usually minimal compared to the cost of discovering that bug.
Boy, I wish!
> Like you say, you typically only die of one thing, so if you know the patient won't die of a particular diagnosis because something else is more likely to kill them, then it might not be worth making that diagnosis.
You can't know someone didn't die of X until after they died, that's the entire point of this dilemma.
It is generally easy to fix a bug that has already be found and can be reproduced (has been diagnosed, so to speak) than to find that bug in the first place. That's one of the reasons that LLM security scanning has become so important recently: it massively reduces the cost of finding those vulnerabilities.
As to your second point, you don't know exactly what a person will die of, but you can make statically sound estimates. You generally won't test unlikely potential causes of death (either because the chance of a positive result is too small, or because you know there are other, more serious conditions). But once a vulnerability is known, it is infinitely reproducible, which means the chance of the vulnerability being "fatal" (assuming the conditions exist for it to be exploited) is essentially 1.
The other flaw in the analogy is that in medicine, the patient chooses to do the tests on themselves. But in software security, there is an adversarial attacker as well as the "doctor" trying to defend the software. And in general, if the defender can find a vulnerability, they must assume that an attacker could already have found the same vulnerability (because the attacker and defender have largely the same tools and information at their disposal, especially in open source contexts), in which case, as discussed previously, that vulnerability also needs to be assumed to be fatal.
The word "generally" contains a lot of assumptions in that first sentence. I can think of a couple of scenarios where fixing a bug can absolutely spiral. There are even cases where the far better outcome is to leave a bug in place now that it is known.
I dare say of we could git revert people after surgery we'd be a lot more relaxed about both undergoing it and letting people do it with less qualifications.
Is it, when the software has the potential to destroy one or more people's lives when things go wrong? Sometimes the devil you know is the far better choice.
The key thing you forgot, which makes this approach non-sensible, is the omniscience, without which you have no clue whether your posture towards a new bug-finding tool is good or not, since you don't know whether it will mostly find those bugs that are not worth fixing and the time wasted on fixing them is detrimental.
Similarly, how is ignorance better than informed decision when ignorance also includes missing critical security bugs?
Same as we do medical tests: We define some bar a test must meet and then the population, if any, it is applicable for and especially the population it is not applicable for because the curse of knowledge exceeds the benefit (eg: breast cancer screenings not recommended for people under 40 or over 74).
This isn't an argument against all automated bug detection, just that it needs to exceed a threshold beyond just "It has found at least one real bug not found via other means" which is the seductive threshold people want it to be.
> The key distinction is that people only ever die of one thing and having a tumor that doesn't kill them is often better than risking the surgery to remove the tumor.
But what applies to humans doesn't apply to software. First, to pursue the metaphor, codebase can definitely die/be compromised/crash because of multiple reasons at the same time; second, there is virtually no risk, out of man-hours, in fixing a bug.
Medicine is fuzzy, software is mostly maths. You can prove your software has no bugs and you increasingly should be proving that. The hard part is knowing if what you prove is what the software is doing.
The percentage of software that is even in theory provable to be bug free is a miniscule proportion of the software we use on a day to day basis. In many cases, simply the act of writing a proof becomes largely idempotent to building bug free software which is impractical.
That depends on the spec you are proving. If you define bug free as won't overflow any buffers and never follow the NULL pointer it might be possible to prove that much. This would be a useful thing to prove for Postgress - even though it could return garbage for every possible select statement and still pass the above proof. If you want to prove postgres does the right thing as well that is much harder to spec - it might not be worth it.
This is great for the same reason open source software is great.
We want software that remains robust in the long term, so that even when people are able to inspect the source code, it's still solid, rather than hiding the source code and hoping people don't find holes everywhere.
Yes, exactly. The only question I have is whether the delay is attributable to high-quality bug reports or the burden of triaging low-quality ones. It's not completely clear which situation they're experiencing.
It's almost never worth spending human time triaging AI reports vs having a different AI go triage them/attempt to replicate them to your standards etc. Obviously it sucks to burn opus or sol tokens on luna or sonnet slop bug reports but it sucks way more to burn human time and attention. And the majority of the time the ai auto filing these bug reports is not in a test harness that's actively replicating findings and focuising on providing a useful report because it's a rogue openclaw dropping drive by github issues and the user didn't tell it to make sure findings are valid before posting them. AT the least a refutation/replication round where you filter out any findings your AI can't reproduce or can prove to be irrelevant is going to help a lot with keeping your sanity
That's kind of what I was afraid of. Both is really bad news. If you think of it in terms of average speed over ground, working on low quality reports is like spending a bunch of time at v=0.
This is good. This is how I would expect llms to affect a codebase. Nothing sucks more than having a coworker put out a code review but your codex immediately finds problems. Run llm/self reviews against your code before you have other humans review it. It is common courtesy.
I think it will be annoying in the short term, but the cleanup this causes will be a good thing in the long term (and of course LLMs can also help with fixing bugs, even without source code.)
Though I don't get why this is delaying the release. It's understandable to delay a release to fix regressions, so that an update will not break things that used to work before. But if a bug has been present for a longtime, why delay shipping a new release with other bug fixes? The fix for that old bug could come in a point release or just next time.
I'm pretty sure that the Luddite's were at least partly concerned with potential for the further exploitation of unskilled labour (in the case of mills at the time - child orphans). I don't think it would be fair to paint them as simply self-interested.
> Luddites were actually pretty reasonable when you dig into it.
No, they were not. The problems they faced were absolutely real, but the solutions they chose to attempt were stupid and counterproductive. Which is why they lost so hard, and it was not even a contest.
Socialism movement that refused to use machines and factories would inevitably lose to capitalists that embraced them.
Socialism movement that refuses to use AI will inevitably lose to capitalists that embrace it.
Is that because of a deeper issue in one of the two philosophies or because we've chosen to define winning with things that exclusively benefit one of the two sides
I mean I don’t feel like sacrificing myself for the “good” of society. Not least because of the fact that a lot of people defining what is “good for society” seem to define it as “good for them” or use it to grab power from others…
I personally preferred to code without AI; but it's objectively possible to do more things now so you're more competitive compared to other people who are not using AI. The tragedy is that since everybody is using AI, we cannot bank those advantages and we're just all going to suffer (a variation on the tragedy of the commons theme)
> In the end, I don’t think that the delay in shipping PostgreSQL 19 is particularly concerning. It is not a long delay in the grand scheme of things, and it emerges directly from the project’s concern for quality.
Did you honestly need a /sarcasm tag in the article?
The article also concludes that overall, yes, finding more bugs is a good thing. Basically saying it’s the LLMs “fault” that the quality is improving, alongside a slight delay to the release.
"They were full of people asking questions and not getting useful answers, with many responses given by users who were more motivated to gain karma in the forum’s user-ranking system than to help." — Jason Snell (https://sixcolors.com/link/2026/11/ding-dong-the-apple-suppo...)
"Good riddance." — John Gruber (https://daringfireball.net/linked/2026/11/11/apple-support-c...)
reply