The spirit of the Declaration is still viable however, even if the shape of the implementation is different from the original idea. Humans are far too chaotic to ever find a singular utopia, online or off, but information technology is still a great enabler for everyone.

There's an increasing trend of articles and blog posts like this one, and unfortunately they share a common theme of complaints about big tech with a call for regulation. Naming and shaming bad actors is good, and not all regulation is bad, but you can't regulate everything to make everyone happy, and eventually you end up in an authoritarian dystopia.

Instead of complaining and waiting around for everyone's preferred flavor of regulation to appear, I suggest we instead embrace the spirit of cyberlibertarianism and DIY solutions that work at a smaller scale. The world is a dangerous place, but we've never had better tools to carve out your own niche and develop solutions to the things that matter to you.

As an aside, I still think there's a place for blockchains. They're not a good replacement for a typical database, but I think some of the concepts are useful. The idea of distributed ledgers and smart contracts have a lot of applications IMHO, particularly in government. The traceability of transactions seems like a great fit to enable transparency of government spending. Of course, governments are allergic to that idea for the usual reasons, but it's still a nice idea. Distributed computing is hard, and it's a shame that blockchains were usurped by crypto bro scams. I'm still rooting for the folks who are trying to push distributed technology forward though.

To me it feels like a worse experience, and they probably feel it too, but it makes sense from an optimization perspective. I've probably learned some shell tricks, but also going blind from watching Claude try dozens of variations of some multi-line chained and piped wall of bash nightmare, instead of just reading a few files.

How many people are writing crud apps using mainstream languages vs COBOL though? You don't need 100% silver bullet 1-shot everything, just to recognize the signals that for many use cases, there's a significant shift happening. The safe space is expanding and velocity is increasing.

I don't think we'll see AAA game velocity change until asset generation progresses quite a bit, not to mention stuff like rigging. Even then, there's still a layer between code and engine where you have to wire everything together which an LLM will struggle with.

Replacing some old COBOL is probably more of a management decision based on appetite for change and politics rather than development speed.

Aren't there some measurable things like github repo creation, PRs, app store additions, etc. that can be correlated to LLM adoption? Didn't Show HN have to get throttled after LLMs arrived?

I don't know how long LLMs will hold their position, but in my mind, it makes sense that computers will eventually be the best programmers. Humans will still guide, but rarely write or even read code. I might be dead by then, but that's my prediction for the future.

The problem is you start getting comfortable and tired of your workflow getting interrupted when the agent needs more/repeated access. Gradually the permission scope increases, or you decide to take the guards off completely. At this point you have a non-deterministic black box with internet access doing things to your computer. Maybe the agent gets confused and force-pushes git, maybe you load load a malicious plugin, or MCP to github and ingest something hostile. The internet isn't getting kinder, it's basically all-out war behind the scenes, and having your agent do online research is an attack vector. Security is layered, and sandboxing is a layer you can add to mitigate some issues and have piece of mind.

TBH I didn't look too closely at the featured product because I have my own solution already, but it sounds like a versioning filesystem is integrated, which can be really handy. Filesystem snapshots are fast and cheap compared to traditional backup/restore operations. Git is a nice layer for text files, but it's slow and not very good for binary stuff, so if you're working with images or 3d models etc, a versioning FS is really useful.

There are lots of agent use cases beyond individual coding. Maybe you're building a multi-tenant product that let's user agents do stuff and you need an undo feature. That's probably a good case for a sandbox with versioning FS. Maybe you have an agent handling contractual transactions that can't afford to oops. LLM agents are an entirely new computing interface, so we should imagine wide variety of use cases, some of which would likely benefit from a sandbox environment that versions data.

What you're suggesting is a negative flywheel where quality spirals down, but I'm hoping it becomes a positive loop and the quality floor goes up. We had plenty of slop before LLMs, and not all LLM output is slop. Time will tell, but I think LLMs will continue to improve their coding abilities and push overall quality higher.