You should not connect a service maintained by individuals in their free time to the public internet. Put it behind a VPN or local network only and then you don’t have to worry.
Delaying disclosures is a false sense of security when the attackers are running the same scans Google is. They will have exploits faster than 30 days.
> Put it behind a VPN or local network only and then you don’t have to worry.
This is not how software works whatsoever, to the extent that I have to wonder what relevant expertise do you have in the area. Like this is for all intents and purposes just nonsensical.
This is the kind of thinking that in the 90s would have kept the internet exclusive to the domains of university and government. Every new technology has risks and people adapt. In the early part of the 20th century we might as well have kept cars away from private citizens and relegated transportation to buses, trains and professional drivers. Need private transportation? Use a horse. What with the number of people killed and maimed every year it's just not worth it. Take away our keys and mandate public transportation please.
No. People will stop caring because they do not wish to have the extra stress of this. Which kills open source and therefore a lot of collaboration and innovation. Not to mention killing the open internet.
I see only two possibilities. If it's a proprietary product that should either be rapidly fixed by the vendor or abandoned by the customer. Alternatively, if it's a FOSS project then if the maintainers are unresponsive the end user can simply request his LLM of choice to patch it for him. I honestly see no issue here. It isn't how things used to work even as recently as a year ago but it seems to be the only sensible way they can work going forward.
That would be the problem of the people running the software, not writing it.
Considering the direction software and their exploits are going with AI, if 30 days is insufficient in 2028 then that's useful signal to the people running that they should move elsewhere.
Only until cybersecurity liability legislation finally starts to kick in, then those writing it will have a solid reason to assign the necessary resources to make it happen.
>Only until cybersecurity liability legislation finally starts to kick in
In America software is protected by the First Amendment, so most software (and all open source for sure) cannot be subjected to "cybersecurity liability" of the sort you seem to be envisioning. Congress could have an angle when it comes to stuff that is sold, including in particular hardware and subscription services though there will be both plenty of lobbying and plenty of potential landmines involved in any such effort.
But with anything free there is no commercial angle involved, no contract. It's just speech that's put out there, identical to the posts we're writing here on HN right now. Software bugs aren't true threats, incitement, defamation, or obscene.
Other countries of course could take a different tack, but they'd then face "OSS becomes fully American" and I'm deeply skeptical that'd work politically.
There is this thing called soverignity where goveremnts can legally track down the citzens who fails to comply, and whose actions can endager the country in whatever means the forces in power decide it may be.
Also when US gets a saner goverment back, I am quite sure CISA will have yet another opinion on the matter, especially if national security is considered exposed in some media case.
>There is this thing called soverignity where goveremnts can legally track down the citzens who fails to comply, and whose actions can endager the country in whatever means the forces in power decide it may be.
Perhaps in your authoritarian fever-dreams or whatever shithole country you current reside in, but no in the US.
>Also when US gets a saner goverment back, I am quite sure CISA will have yet another opinion on the matter, especially if national security is considered exposed in some media case.
Any sensible legislation will unconditionally exempt the authors of FOSS software. If that is ever not the case the logical consequence is all FOSS contributors moving to pseudnonymous identities and collaborating exclusively via tor.
For example see the EU cyber resilience act (regulation 2024/2847). It sets out nuanced rules regarding FOSS.
If you simply run or contribute to a FOSS project then you don't have any obligations, those kick in when you distribute software for profit and your obligations scale with the size of your business. Companies that fail to promptly address security vulnerabilities will face strict liability for damages.
You misunderstand - denying patches to downstream vendors improves financial security for Google.
But they actually did this to comply with the EU Cyber Resilience Act. When a patch is released, a legal clock starts ticking - anyone who doesn't apply it promptly is liable for any resulting damages.
> And there has been strictly zero progress on this and IMO this isn't something LLMs are structurally capable of doing.
Totally agree with this.
I see the future of what an IDE is more like an "architecture designing interface" which designs tests, architectural decisions, type systems, and contracts between components. Tasks then should be delegated in their implementations to agents so they are just responsible for the "wiring parts together" tasks.
Currently I imagine it as something similar to how workflows are usually designed around strong types and schema validations in safety-critical areas like ASPICE, Ada Spark, etc.
That's mostly why I don't use existing agentic environments and started earlier this year to experiment with my own one, where I try to enforce the design and architecture related tasks through capabilities mapped on tools for each of the task-scoped roles involved.
Wanted to add that LLMs have become incredibly good at reverse engineering such devices, even when they don't have postmarketOS (now "Nura") or upstream kernel support yet. Been able to merge kernel changes and backport driver support to upstream kernels pretty easily by just giving them access to UART. They'll just go ahead and figure out all the partitioning and firmware quirks by themselves, and e.g. OpenWRT instructions seem to be well documented in the wiki so they'll understand the process on how to get there almost completely by themselves.
For my malware home lab, I decided to just reuse old phones and routers that nobody wanted anymore (quite literally got them from the trash bins). Now they're running an ARMv8 kernel as the host kernel and the rest is emulated or containerized, depending on the use case.
Works like a charm for most tasks I throw at it, and many old cheap Android phones have at least quad or octa cores in them, making them pretty awesome for podman/docker usage, too.
The only thing you have to look out for is to remove the battery, and that you use a separate power circuit with a step down converter to power it. But other than that, old smartphones have become amazing for selfhosting stuff now.
> (...) that agents are currently pretty good at it if guided properly.
I think I partially agree with that.
If you create your type system and templates first, agents can be pretty helpful filling in the blanks or "wiring"/integrating an external API into your own type system.
The issue is that I always have to force agents to read that type system before I can prompt them with a task like this, and always have to prompt them to not touch/extend/modify that type system and to use existing codestyles etc.
So I guess I haven't figured out a good type system discovery in my workflows yet. Would be interesting to see how you work with agents here.
Got an open sourced repo by chance where the structure worked out well?
> Got an open sourced repo by chance where the structure worked out well?
I have an AGENTS.md that I bring around in every repo.
Few things I found:
- On new project is that it is much more efficient to point the agent on an old, existing project and simply say "Copy the code style" than to try to document everything in a markdown file.
- Explicit listing of both headers and implementation in CMake target seems to help for dependency resolution.
- A simple "Analyze this codebase" on a folder helps a lot for context prefilling on complex type system. I have a compiler where the entire language grammar is defined as C++ types with mutual relations. DeepSeek is completely capable to understand it and debug grammar mistakes in a blink of an eye.
Personally, I've never seen anyone write C++ codebases without boost. As you pointed out, the only practical way seems to be to constraint its feature complexity through meta programming.
Coming from the embedded C++ world where resources are scarce, C++ and its debugger ecosystem have been really nice. There were usually strong vendor provided SDKs and cross compilation toolchains available.
The issues I had with the language were mostly dependencies on vendors, not effectively being able to fix problems in SDKs, and as you also mentioned the footguns.
Lots of frustrations came from codestyle, branch conventions and type conventions we tried to encode into templates, which new team members had to learn before they could write any production code. So from a team perspective a lot of productivity came from reproducible build pipelines and setups. Having one team member on Windows and the other on macOS or Linux was as painful as it can get, especially with getting gcc's ecosystem to work properly. So you were also really dependent on Docker cross architecture images. And setting those up just for the sake of compilation was also unnecessary overhead.
These days I've migrated towards Go for pretty much all tasks I can think of, mostly for the tight integration with the C ABI ecosystem and tinygo and the easy possibility to cross compile into fat binaries.
What I miss though is a "real IDE" like the old Visual Studio, or geany or whatever. Most IDEs are not symbol based anymore, which makes them really painful to use in terms of what I expect an IDE to offer to be able to call itself an IDE. But maybe this is just my C++ heart bleeding all over the place because I miss good and typed API documentation examples that I can explore through clicking rather than having to google every function all the time.
In all seriousness, there is nobody at Anthropic who can even give you that answer, because nobody there reads their pushed code anymore. Take a look at the previous Claude Code leaked codebases if you don't believe me, there is hundreds of files with 1000+ or more import statements at the top.
Any human would immediately tell you that it needs to be refactored from scratch. Their codebase also leaked that they're using review bots automatically instead of a human-in-the-loop review process.
If the docs are vibecoded too that would explain why there's a link to the compromised "not official" cursor version of the extension here https://code.claude.com/docs/en/vs-code which they supposedly aren't responsible for.
It sure seems like they've been vibecoding with everyone asleep at the wheel for a while.
Some (likely most) projects have just non-paid people working on it in their free time. That's the reality of open source.
reply