The Eternal Sloptember

> it's a force majeur

I assume you meant something like 'force multiplier"? Force Majeure is an uncontrollable event that prevents a party from fulfilling a contract. Which some may argue is what AI will also deliver. :)

On Saturday I thought I had vibe coded myself into a mess. I had implemented a new block type in my structured editor for Practal Zero (or rather let Codex do it), and suddenly the syntax highlighting broke in the whole document. Asking Codex to fix it didn't work. I was contemplating to restart the whole project on a basis that I actually fully understand, but that would set me back so much when the first reasonable prototype seemed so close. Instead, I took a walk.

See, the project actually has a well thought out structure that I design carefully, but more and more of it gets filled out by Codex. Codex is not smart enough to remember all the high-level design considerations, some of which had not been documented because I was just implicitly assuming them. So the fix was to use Codex to isolate the error, think about in terms of the high-level design, and fix the problem, which was partially an implementation problem, and partially a problem of the high-level design.

I fixed the high-level design with discussions with Codex, and documenting this, and then let Codex implement the fixes. The discussion took me more than an hour, the implementation was done in a few minutes.

This working style is similar to doing math: You have a high-level idea of what you are doing, and let that guide you, and Codex assumes the role of something that fills out all of the details you take for granted. Often it turns out your high-level idea had flaws, and this shows up in your code not working as expected. So you revise your high-level idea, refactor the code to reflect the modified high-level design, rinse and repeat.

Working this way is still really hard, but it allows me to do things I could not have done before. Getting your ideas validated (or refuted) in minutes instead of days is huge, and makes it possible to march through stuff that would have turned into a deadly swamp before, at least for me.

Now. Do I think that most corporate programmers will use Codex or CC in this way? I don't know, but I think probably not. So what will stop them going into the swamp until it swallows them, instead of backing up in time and marching around it?

Correct. In Chinese all nouns require them.

(It's not the case, however, that all measure words require nouns. 天 ("day") and 年 ("year") are measure words that are almost always used on their own. There might be an implicit notion of "one day of time" or similar.)

When I started coding with AI I would copy / paste code into GPT-3.5 and ask it to update the code, it was a massive productivity boost, minor changes, fully reviewed. Then VSCode allowed tabbing, it was okayish, but I had my finger on the pulse and knew exactly what was changed and had an opinion on the suggestions. Then cursor allowed you to see and approve changes, after a few changes it started making bigger changes but had an review and approve process, things were starting to feel more magic and required more discipline to be on top of changes. Then YOLO mode hit and you could make massive changes, slowly it became easier and easier to just let the AI build code and you just guide it.

The issue is people mix up complexity, novelty, repeatability and scale.

Well documented complex problems can easily be solved by LLMs.

Doing the same thing over and over again is easy for an LLM.

Novelty and scale is very hard for an LLM.

Even small novel problems confuse LLMs.

When you start a new code base the LLM smashes through the boilerplate work. Then when it gets to scale it struggles with context rot plus novelty.

In the end, the worst part wasn't just loosing artisan jobs and destroying the market for crafted goods. The second order effect was to create a new kind of drudgery in the repetitive and sometimes dangerous work of maintaining the operations of the machine. It created a class of workers who were completely dependent on these kinds of jobs.