adamddev1

Great write-up. People keep saying "we can just write tests" or more recently "we can use formal verification," thinking these are sufficient safeguards we can use and then relegate all the implementation to LLMs. But the fact is that probabilistic guessing machines can't save them. People can't escape the need to actually understand the things they are building.

Exactly. Software seems to be getting worse. The internet is getting filled with more and more bloat and falsehoods.

I have yet to see any truly great products made with heavily agentic coding. Correct me if I'm wrong?

But what does "getting left behind" mean? Not producing as many LOC or apps as someone else?

The old "Mythical Man Month" might apply here. Throwing bigger swarms of agents at things and making bigger projects may not lead to more progress and usefulness.

Often it's the small, insightful, well-crafted thing that goes much further than 100 decent projects. Git was a little tool written on a weekend and it went a lot further than giant projects written by giant teams.

Alan Kay answering questions on Quora. What a cool gift to the world!

This is one of the thing we lose as more and more of the conversations turn to people privately asking LLMs things, who do their best to scrape out answers from the existing info or make up a best guess. People are losing the ability to ask experts with real, unique knowledge and then share that knowledge with humanity.

Excellent post. People always defend agentic/LLM-driven development by saying, "Well it's good enough", or "It works most of the time."

That may be tolerable for some user-facing app. But what if we start normalizing failures in the libraries, the infrastructure, and the compilers? Everything descends into a mess of unreliability, and that slows EVERYTHING and EVERYONE down.

I think that that the "they're destroying jobs" or even then "they're stealing intellectual property" argument overshadows or distracts from the more important issues. What really concerns me is the large scale erosion of truth and reliability. Codebases and the internet at large are being flooded with less and less accurate information, with more bloat, and with more errors that will exponentially increase as more and more is built on them.

Faulty decisions based on patterns (and prejudice) will be made by models trained on a mixture of truth and falsehoods. These decisions will affect, and even kill people. There have always been some people who choose quick results and productivity over truth, but now we are seeing a mass scaling and automation of this mentality. But when people just hear "they're taking jobs" it's easy to dismiss those with concerns as Luddites.

Why does a blog page need three loading spinners at the top to load a couple of simple text banners asynchronously?! ... And this from one of the biggest software giants. We have fallen so far.

I just tried ChatGPT on a simple find an error in the proof question today and it completely butchered it ignoring the main constraint that two variables a and b were natural numbers. It said, "a and b might not be natural numbers" and then went on to produce a very elaborate, completely wrong answer.

Thank you. The apps created like this are absolutely an embarrassment. But to me the bigger horror is if people are going to be convinced to develop the critical libraries and infrastructure in the same way. Then we'll have bloat and rot in the deeper levels and everything will become exponentially worse and unreliable. It makes me so sad that people can't see this.

When people talk about AI being able to handle everything I keep wondering, have these people built anything complex, novel or serious? Just because people can see a website or a simple app improved, does that mean that all code can be handled by LLMs? It's like people are totally forgetting a whole category of careful, well-thought out programming for the critical parts.

Well summarized, but I believe this is sadly why we're seeing a decline in software quality all over. And if people keep following this trend for libraries and core utilities... yikes things will get bad.

It's more than that though. I authored the original work. Then the Baron in the Castle collected the work and uses it without fully understanding it. The Baron gives it out but in a partly-true, distorted form. He misunderstand how it applies and teaches people false clearly facts with it, with an air of authority. But when people try to find the source argument to see if the Baron is really on track, they have no idea. The Baron is just confidently parroting a compelling sounding set of words.

For me the issue is more about the loss of truth than the loss of my IP.

I wrote something original in a language learning grammar online. I coined a term to describe something about how a certain language with negative language functions.

I tried talking to an LLM about it and sure and enough, it had scraped it and learned to use that terminology and explanation that I made up. I asked the LLM, "Where did that concept/term come from, who made it up?" It did a bunch of searching and tried to site a whole bunch of other sources which did NOT contain the terms of the explanation I had written. It simply would not cite or mention my source. It kept parroting my material semi-correctly and hiding the source. By any other actor that would be an egregious act of sloppiness, dishonesty, and plagiarism.

Generative AI is speed-running a widespread corruption of truth. I do not believe any of the gains are worth this.

Or like the difference between chemistry and alchemy? Understanding and reasoning with the building blocks as opposed to throwing random stuff together, trying different things and hoping it somehow produces gold.

I like the name `fold` as used by Haskell, Racket, et al. It gives me an image of folding up a long list into a ball, one chunk at a time.

I just pulled a PWA app off the app store and I am going to keep it a pure PWA. It's installable, offline-first. I know I feel like I'm swimming against the current but I would love people to try to push for awareness of PWA installs more.

LLMs are probabilistic, not deterministic.

Yes of course, but you also understand that as Dijkstra said "tests cannot show the absence of bugs."

Tests can show you problems, if you can find them, but they cannot show that there are no problems. Property based testing or fuzzing gets your more coverage, and is a good step, but it is still nothing compared to proving things or understanding how something is built and that it is solid. Testing works towards checking for reliability and robustness, but often it's only 10% (?) of the job.

Compilers are deterministic.

Testing is an extremely inadequate measure of reliability and robustness.

Would I be wrong to assume that you are building end-user applications?

If people use AI for libraries, OSs, and mission critical software, the apparent productivity gains would have to be weighed against the reliability and performance hits that bubble up to the things that are built on them and rely on them.

A similar line of thought is used to justify corruption:

"Corruption is not going away so people will have to get used to it. The alternative is making less money than people who are happy to take bribes."

The first thing I notice is an AGENTS.md in the repo.

There's also often the obligatory "well, we still have to use these tools so perhaps we could use them better like this." As if just not using them wasn't an option.

Reminds me of the good 'ol Apple II BASIC. You can name your variables whatever you want, but only the first two letters matter.

It was a joke if you read the article.

Right, programmers also use randomly generated info from property based testing for example? But I was referencing the analogy to the abacus, calculator, logarithms, analysis, and higher level languages.

> Have mathematicians become "less savvy" since the invention of the abacus or calculator? The invention of logarithms or analysis?

This is not a fair analogy. Those things are like compilers, languages, and type-checkers. They are deterministic, carefully proven, hand-crafted tools, that allow people to go safely to a higher level of abstraction and still make things in a deterministic way. The jump into the fuzzy world of LLMs is a completely different thing. It's different than the jump from assembly to a higher-level language.

> “I’ve told four separate therapists about Typebase. Two stopped taking me as a client. The other two are now shipping an app with it.”

So good. I laughed out loud at this.

It would be amazing if everyone would boycott the app stores as much as possible and normalize PWAs. People would learn if they got common enough. But alas, I doubt this will happen.