[westoque]

> The problem for me is that the development practices of the people that are working on it are suboptimal at best; they're constantly releasing at an extremely high cadence, where they don't even spend the time to test or fix things (or even build a proper list of changes for each release), and they add, remove, refine, change, fix, and break features constantly at that accelerated pace.

this is what i notice with openclaw as well. there have been releases where they break production features. unfortunately this is what happens when code becomes a commidity, everyone thinks that shipping fast is the moat but at the expense of suboptimality since they know a fix can be implemented quickly on the next release.

[siddboots]

Openclaw has 20k commits, almost 700k lines of code, and it is only four months old. I feel confident that that sort of code base would have a no coherent architecture at all, and also that no human has a good mental model of how the various subsystems interact.

I’m sure we’ll all learn a lot from these early days of agentic coding.

[girvo]

> I’m sure we’ll all learn a lot from these early days of agentic coding.

So far what I am learning (from watching all of this) is that our constant claims that quality and security matter seem to not be true on average. Depressingly.

[nunchiai]

I think what we're seeing is a phase transition. In the early days of any paradigm shift, velocity trumps stability because the market rewards first movers.

But as agents move from prototypes to production, the calculus changes. Production systems need: - Memory continuity across sessions - Predictable behavior across updates - Security boundaries that don't leak

The tools that prioritize these will win the enterprise market. The ones that don't will stay in the prototype/hobbyist space.

We're still in the "move fast" phase, but the "break things" part is starting to hurt real users. The pendulum will swing back.

[imtringued]

This makes sense. Development velocity is bought by having a short product life with few users. As you gain users that depend on your product, velocity must drop by definition.

The reason for this is that product development involves making decisions which can later be classified as good or bad decisions.

The good decisions must remain stable, while the bad decisions must remain open to change and therefore remain unstable.

The AI doesn't know anything about the user experience, which means it will inevitably change the good decisions as well.

[lelanthran]

> So far what I am learning (from watching all of this) is that our constant claims that quality and security matter seem to not be true on average.

Only for the non-pro users. After all, those users were happy to use excel to write the programs.

What we're seeing now is that more and more developers find they are happy with even less determinism than the Excel process.

Maybe they're right; maybe software doesn't need any coherence, stability, security or even correctness. Maybe the class of software they produce doesn't need those things.

I, unfortunately, am unable to adopt this view.

[_n66o]

I still use excel to write programs. I use officescript and power query. I shy away from via but have also used it.. I’m not sure what your point is. The people stopping citizens’ development could ease off the job security lines and the deferral to lockdown

[staticassertion]

> our constant claims that quality and security matter

I'm 13 years into this industry, this is the first I'm hearing of this.

[usagisushi]

I’ve heard the "S" in IoT stands for Security.

[baq]

same with openclaw

[girvo]

20 for me, and let's not exaggerate. We've given lip service to it this entire time. Hell look at any of the corps we're talking about (including where I work) and they're demanding "velocity without lowering the quality bar", but it's a lie: they don't care about the quality bar in the slightest.

[raesene9]

One of my main lessons after a decent long while in security, is that most orgs care about security, *as long as it doesn't get in the way of other priorities* like shipping new features. So when we get something like Agentic LLM tooling where everything moves super fast, security is inevitably going to suffer.

[blks]

I’m learning that projects, developed with the help of agents, even when developers claim that they review and steer everything, ultimately are not fully understood or owned by the developers, and very soon turns into a thousand reinvented wheels strapped together by tape.

[KronisLV]

> very soon turns into a thousand reinvented wheels strapped together by tape.

Also most of the long running enterprise projects I’ve seen - there was one that had been around for like 10 years and like about 75% of the devs I hadn’t even heard of and none of the original ones were in the project at all.

The thing had no less than three auditing mechanisms, three ways of interacting with the database, mixed naming conventions, like two validation mechanisms none of which were what Spring recommended and also configurations versioned for app servers that weren’t even in use.

This was all before AI, it’s not like you need it for projects to turn into slop and AI slop isn’t that much different from human slop (none of them gave a shit about ADRs or proper docs on why things are done a certain way, though Wiki had some fossilized meeting notes with nothing actually useful) except that AI can produce this stuff more quickly.

When encountered, I just relied on writing tests and reworking the older slop with something newer (with better AI models and tooling) and the overall quality improved.

[bredren]

Claude Code breaks production features and doesn't say anything about it. The product has just shifted gears with little to no ceremony.

I expect that from something guiding the market, but there have been times where stuff changes, and it isn't even clear if it is a bug or a permanent decision. I suspect they don't even know.

[heavyset_go]

We're still in the very early days of generative AI, and people and markets are already prioritizing quality over quantity. Quantity is irrelevant when it comes value.

All code is not fungible, "irreverent code that kinda looks okay at first glance" might be a commodity, but well-tested, well-designed and well-understood code is what's valuable.

[danielovichdk]

Generative what? Code is not a thing anymore, in fact it never really was, but now it's definitely not.

Code today can be as verbose and ugly as ever, because from here on out, fewer people are going to read it, understand and care about it.

What's valuable, and you know this I think, is how much money your software will sell for, not how fine and polished your code is.

Code was a liability. Today it's a liability that cost much much less.

[sleepychu]

and once you've got your wish: ugly code without tests or a way to comprehend it, but cheap!

How much value are you going to be able to extract over its lifetime once your customers want to see some additional features or improvements?

How much expensive maintenance burden are you incurring once any change (human or LLM generated) is likely to introduce bugs you have no better way of identifying than shipping to your paying customers?

Maybe LLM+tooling is going to get there with producing a comprehensible and well tested system but my anectodal experience is not promising. I find that AI is great until you hit its limit on a topic and then it will merrily generate tokens in a loop suggesting the same won't-work-fix forever.

[babol]

What you wrote aligns with my experience so far. It's fast and easy to get something working, but in a number of cases it (Opus) just gets stuck 'spinning' and no number of prompts is going to fix that. Moreover - when creating things from scratch it tends to use average/insecure/ inefficient approaches that later take a lot of time to fix.

The whole thing reminds me a bit of the many RAD tools that were supposed to 'solve' programming. While it was easy to start and produce something with those tools, at some point you started spending way too much time working around the limitations and wished you started from scratch without it.

[heavyset_go]

I'm of the opinion that the diligence of experts is part of what makes code valuable assets, and that the market does an alright job of eventually differentiating between reliable products/brands and operations that are just winging it with AI[1].

[1] https://museumoffailure.com/exhibition/wonka-chocolate-exper...

[galaxyLogic]

I would think that the better the code is designed and factored and refactored, the easier it is to maintain and evolve, detect and remove bugs and security vulnerabilties from it. The ease of maintenance helps both AI and humans.

There are limits to what even AI can do to code, within practical time-limits. Using AI also costs money. So, easier it is to maintain and evolve a piece of software, the cheaper it will be to the owners of that application.

[ajb]

You may not need to read it, but you still need to test it.

Code that has not been thoroughly tested is a greater liability, not a lesser one.l, the faster you can write it.

[the_black_hand]

It's understandable and even desirable that a new piece of code rapidly evolves as they iterate and fix bugs. I'd only be concerned if they keep this pattern for too long. In the early phases, I like keeping up with all the cutting edge developments. Projects where dev get afraid to ship because of breaking things end up becoming bloated with unnecessary backward compatibility.