adamddev1

Nothing good comes from vib...

Ok, this is awesome.

Not every answer is on the internet.

Perhaps the ultimate use case would be to use AI to scan, debug and find issues etc, but never to generate new code. Still have humans writing and understanding everything, keeping things as clean and concise as possible.

The people who have this "hobby" attitude of really appreciating the well made steps are the ones that are making deep advances and truly solid things that are used in the long term.

But not getting past the forefront of what's known and written by humans, right? (Aside from filling in math proofs by broad searching and brute forcing known lemmas?)

Last week and tonight I tried asking a frontier model a couple of basic questions about a language with 60-70 million speakers with that I'm an expert on. It gave absolutely brutal, confidently wrong answers. It was completely confused and about the basic structure of the language.

This is a really important point. Honest question, have we ever seen LLMs doing or creating something truly novel or innovative? I mean they can patch together proofs (or functions/programs - same thing via Curry-Howard) by broad searching existing lemmas they can piece together, but create something truly novel and insightful? That seems to be the limit?

> The world has changed; AI is reliable; we need to adapt.

Yes, but I think it's important to state that it's only reliable for things that are very well known and extensively written about.

> But now you can do that work to an ±80% quality level of the old, manual way, but in 1% of the time.

But what happens when the 20% quality margin that we lost aggregates over different layers of infrastructure and compounds into brokenness and chaos?

It's a corruption mentality. They assume everybody else is cheating and lying and everything is broken, so it doesn't matter if they lie, cheat, and break things. The important thing is what you can get away with and what you can get: apps that make money, features shipped to satisfy managers and get the paycheck. And then never think about the long term consequences. And a big part of this mindset is ridiculing or belittling those that care about doing things properly. This is the same mindset that is present in areas with high levels of corruption.

I am also tired of the argument. Yes, people made messy, buggy things before. But AI agents provide away to create messiness and bugginess on an ever increasing scale. And just because things were bad before doesn't mean we should accept making them worse.

Or if the codebase becomes too broken, messy, and bloated to run or manage, people might realize that the crazy Anti-AI people weren't so crazy.

Exactly. How do they now that the spec that was generated was correct? Is the spec also AI generated, and could the models lie to make a spec they can verify, just like they lie to make tests pass?

It is also interesting how the LLM optimists are leaning on tools like Rocq and Lean to save them from the mess of uncertainty and confusion. These are tools created by people who understood their code and worked with deeply with type theory etc. People can keep thinking they can get away with making products from vibes, but down in the infrastructure they still have to depend on people thinking and building carefully.

It is hypocritical to campaign for "nobody will look at code anymore" while depending on the hard work of people who carefully look at code.

I think "no one will build their mental muscle like this anymore" is a bit defeatist. I am still pushing myself coding new and challenging things by hand, not using AI at all for it.

Very cool and thanks for sharing! It's inspiring to see that yes, one person can build something like this. And of course it does NOT have that immediate AI feel. Just a glance and you can feel that it is a true, original work of art. It's also sad to think that so many will not be learning as much as you did thinking this all out and coding by hand.

I think we need to keep pushing back against this idea that "now it's the AI coding era, everything gets coded with AI." Let's keep building things, especially passion projects carefully by hand and normalizing this. Lots of us are still coding without AI.

In what kind of applications do you mean business logic?

This is a one possible approach/explanation:

https://pragprog.com/titles/swdddf/domain-modeling-made-func...

I disagree. Code can be/was more malleable if it's designed well, especially with pure FP. People kept on moving away from messy abstractions and OOP and more towards this idea of pure functions and composition, creating more robust and malleable software.

Now instead of aiming for robust, malleable code, people are throwing up their hands and saying, "It was always a mess, let's just keep throwing more tokens at it."

Oh man, the memories that music brings back. N64 was magical when it first came out. We used to rent it from Blockbuster Video for parties with friends.

This is little glimpse of how incredibly manipulated LLM results can be. Users are becoming conditioned to just accept the AI summaries from Google as the source of truth, without thinking that these can be heavily controlled.

Sorry I was thinking like formal verification like proving something is correct. I guess testing can be considered a form of "dynamic verification."

But there is the problem that tests only check or verify a small sample of possible cases or inputs. They can never show that the program is correct. (Famous Dijkstra statement.) To know something is really correct you have to understand and prove it.

The only answer is to not ship code you don't understand. And I think the easiest way to do that is not use AI for ANYTHING except troubleshooting and doc searching. Those that draw a land in the sand and develop this way will be slower in the short term but their work will last out in the long term because it will be more solid.

That is the problem. Because it's not a clearly abstracted and well designed system, it's not robust for adding features and changing things around. When you try to add something or move something around the big fragile ball of tests breaks and you have to spend forever re-piecing things together or burning heaps of tokens for little changes.

> Trust, but verify.

Testing is NOT verification.

EDIT: Sorry, oops, it's also called a kind of verification.

> "I just got tired of having to read tons of documentation for fragmented libraries and frameworks, and AI is a "solution" to that."

That seems like an solution to the kind of programming that is piping together little pieces of business logic with all kinds of different APIs and services all over. I agree that AI is helpful to distill the piles of documentation and things to learn.

But I mostly enjoy a different kind of programming where you work on a big complicated problem / business logic that sits mostly within the bounds of a defined language setting. The craft of finding more and more elegant, far-reaching, and correct abstractions, and then being able to build things out confidently from those well found abstractions is, in my mind, the greatest joy, and also what AI seems the worst at.

I think it also depends on what kind of application you're writing.

Is most of the "business" within the inner logic, and you've got a complicated internal logical process you want to keep safe and solid? Haskell shines.

Do you have a fairly (internally) simple app that does a lot of reaching in and out to the messy outside world? Haskell might not be the most pleasant experience, to put it lightly.

I meant also in terms of space and time complexity with the slower, bloatier software at every level, things would also freeze and fill up.

What people can get away with on the upper crust with end-user apps would spell disaster for the inner parts.

The more of Haskell's ideas that bleed into mainstream languages, the happier the world will become. It is just so beautiful how these higher abstractions can become so useful and powerful for tying all kinds of things together.

Imagine if the vibe-coders get their way and we see this level of bloat and bugginess at EVERY level of the software stack. Everything would collapse.

Any experience with Rocq? I've been curious about jumping into dependent types.

Reinhard Müller, a German philosopher and mathematician has written extensively about this, warning people about these dangers. Essentially, people would be judged by patterns and prejudice, with no recourse to the logic of the decision or the criteria.

"AI and the New Fascism" - https://rainermuehlhoff.de/en/KI-und-der-neue-Faschismus-Rec...