That said, I also think everyone who contributed content online deserves to be rewarded for their contribution, especially since OpenAI (which made the largest contribution) was a non-profit in the beginning. So there should be some kind of tax. Otherwise I agree, it's not ethical. It's not 'fair use' of copyrights.

It's going to destroy a lot of startups which were monetizing this exact idea. But clearly it's a low-hanging fruit so it makes sense that OpenAI would do it.

Seems we're on the same wavelength because I had the exact same thought about this.

But actually, I'm probably not so fussy. I wouldn't mind cleaning up the mess if I'm paid hourly... But now my concern is: What if they want me to clean up the mess but demand that I do it in a particular way which makes it impossible?

I'm already seeing signs of this. This was already kind of the case in my last job; I had to fix things and implement new features but we had to keep the same clunky, over-engineered architecture. My current job doesn't have the same degree of architectural legacy baggage but there is a lot of bureaucracy to deal with instead, which is itself restrictive.

Just watch the software engineers who say "Let's be careful" lose their jobs and get replaced by non-technical vibe-coders churning out 10K lines of dirty insecure, unmaintainable code per day... Ticking time bomb.

I swear, good engineers are going to move to North Korea to monetize because of the amount and size of 'opportunities' this will create.

It seems so far-fetched but that's the direction it seems to be heading.

There are project I've built from scratch that I would feel confident to hand off to a bunch of non-technical vibe coders and I know they would be productive and the product would likely be secure; because the existing codebase already exhibits all the patterns and principles that are required for that kind of project.

It would probably slowly degrade over time if a lot of vibe-coded logic is added on top but I think they could get very far feature-wise whilst keeping the software reliable.

But even though the value of such codebase has increased, people haven't adapted to this new reality. People are generally not good at telling what is good code. Because we don't actually have consensus on a definition. My definition is that good code is code that is easy to extend and maintain.

If implementing a feature requires a huge amount of tokens, then there's a good chance the codebase is not great.

I've worked on a codebase where a small feature requires might require 3k tokens, but on a different codebase, a feature of similar complexity would require 30k tokens minimum... And it's not about the size of the project; it's more about how the logic is divided and the architecture. And importantly; it's not a one-off; it's a clear observable, repeatable pattern.

Anyway databases nowadays are a commodity. A sticky commodity but nonetheless they are replaceable; increasingly so in the age of AI where data migrations are easier than ever.

Even if each user gets their own sandbox, they will still want to configure different access rules for different kinds of data which they host.

That said the idea that each user could control and host their own data is interesting and could work. I imagine you could have apps which link data from many different user sandboxes via remote foreign keys.

You could have a centralized data schema controlled by the application owner but the data itself would be held/scattered across a large number of sandboxes.

I got interested in this specific idea back in the early days of Firebase I saw someone built a realtime HTML component with PolymerJS called 'collection' and I became consumed by the idea of fully generic realtime self-updating components. My approach is a bit different than OP or that of HTMX though; it's JSON over the wire, not HTML.

I've built a full implementation in Node.js with a set of declarative frontend components.

https://github.com/Saasufy/saasufy-components?tab=readme-ov-...

And https://saasufy.com/

I'm thinking to make open source.

It's nice to see major frameworks coming to a similar conclusion.

I think partly it's because the training set contains a lot of JS, but also because complex software written in JavaScript must have impeccable architecture in order to exist at all.

It's rare to encounter a complex, functioning JavaScript application with bad architecture. I've never met any engineer smart enough to maintain a large spaghetti-code JavaScript project.

On the other hand, I've seen horrible TypeScript projects. If it wasn't for the helpful type annotations, no human being would have been able to maintain it.

But we can't drop all abstractions. It's not physically possible. The AI agent is going to break logic up into files... The AI will create/impose an abstraction for each piece of logic whether we like it or not.

So saying "drop abstractions" is actually saying "let the AI decide what the abstractions should be" and unfortunately because LLMs are trained on average code, those abstractions are often pretty poor.

Coming up with the right abstractions is actually one of the main skills which AI hasn't automated and where the human brings the most value. It affects maintainability directly; including when using AI.

I've worked on projects with poor abstractions and ones with good abstractions using AI. The ones with poor abstractions require 10x to 100x more tokens and time to solve problems and implement new features. You're constantly fighting it to prevent it from coming up with nasty hacks and workarounds. Poor abstractions create the need for hacks and workarounds.

A good abstraction is a single edged sword which simplifies the task. A mediocre abstraction is a double-edged sword. A bad abstraction is like a single edged sword with a restrictive handle and the sharp edge is facing towards you.

For vibe coders.

With a focus on:

- Security

- Analytics

- Advanced data sharing scenarios

- Realtime updates

Claude can be given full access to your control panel and can impersonate any role to exhaustively test all your data models and views. So even a fool can exhaustively prove the security of their application for all data in their system.

The article stops exactly where I did and doesn't go further into SPHINCS+ which builds on top of the same primitives to provide statelessness.

And the reason I stopped at that was probably the same. There is already a fair amount of complexity involved. I wanted a signature scheme which would be relatively simple to understand and implement. Also, there were no good SPHINCS implementations at the time for my engine/language and I didn't feel confident to implement from scratch.

Also, no project at the time (except I think IOTA) had stateful signatures and I liked the idea of being able to change passphrases as it could potentially allow people to sell their wallets (along with associated DEX memberships or delegate spots) to other people.

At the time, I was forging as a delegate on a different DPoS blockchain and I was thinking that it would be nice if I could sell my wallet (which would have been worth 5x to 10x my annual block earnings)... Unfortunately, I couldn't do that (no mechanism for it) and I ended up losing that income stream, never having the option to cash out.

Firstly, people don't agree on what good code is (developers who get paid by the hour tend to favor complexity so they think good code is complex code), secondly, AI companies have an incentive to produce more tokens; this works against good architecture since good architecture would cost fewer tokens to maintain. Thirdly, many decision makers tend to conflate complexity with intelligence, hence they are more likely to prefer complex solutions over optimal ones.

If I'm knowledgeable in a niche over which there is no mainstream consensus or it's disorganized, and I want to reason more about this topic, I need the AI in the rabbit hole with me. I don't need it to question the existence of the rabbit hole I'm in. Otherwise all of its arguments sound like gaslighting; asking me to disbelieve my eyes and decades of experience about basic ideas which I've already researched many times and proven not to work (at least with high confidence).

For me this happens with some niches of software engineering and architecture and I have lots of physical proof of working, secure, maintainable software to back up my position.

Also, when I say that "most of my contrarian ideas are correct" it's with the caveat that I don't tend to adopt or hold onto contrarian ideas that are easily proven to be incorrect. I'm referring to the kinds of niche ideas which most non-experts would not feel confident to make strong arguments about but AI will.

All this doesn't necessarily translate to sales though. Because, to evaluate those things requires attention, trust, time and effort.

This is a significant barrier because a lot of software will appear to meet all of these superficially.

After 1 day of usage, a piece of software may appear to be intuitive, reliable, secure, performant and useful... But then after some time (sometimes a whole week or longer) you run into a critical scenario and discover that it cannot be solved with that software... Or performance drops off sharply after you created the 1000th record in the software... Or a hacker takes months to find that one endpoint which allows full remote code execution.

Even in an optimistic scenario, 1 week is a long time to evaluate a piece of software. I've encountered software which took 6 months and large teams of people to realize that it wasn't suitable. That's how long it took to hit the critical limits. It's a very long evaluation loop.

So you cannot judge new software efficiently by just looking at it. Even industry consensus is problematic if the software is very new and complex... Plenty of trends have fallen off a cliff in the past. You need to understand who is behind the software... And even that's not so easy; social proof can be misleading when it comes to deep technical ideas. The people who are good at social networking aren't necessarily good with tech.

I think AI slop code is going to be a much bigger problem than people anticipate. And the irony of it is that the solutions already exist... What doesn't exist is the mechanism to identify those solutions. But even the mindset needs to be corrected first.