It doesn't even have to be that convoluted. Any sudden dangerous situation: natural disaster, break in, medical emergency(positive or negative what about a baby being born) where a car is the only solution and a reasonable, but inebriated, person makes the better of two bad decisions is going to need an override. I don't want to be pessimistic but this really seems like the sort of thing where a few people will die, lawsuits will happen, congress will mandate an override/make it optional, it'll be gone in maybe 10 years. It's madness but seemingly this is how things are done.

More likely is that very expensive cars will have an override switch and cheaper cars won't.

I do not think it will happen but this is why in discussions about this happening, or historical fiction, typically the places that break off are the ones that were distinct _before_ they joined the US. Any of the 13 colonies, New England as a block having the strongest colonial identity that I'm aware of, Texas, or California generally are where it's assumed to start as those were countries/had identities very much outside of the US while also having economies that might be ok.

```

hs.loadSpoon("MicMute")

binding = { toggle = { {"ctrl", "alt"}, "m" } }

spoon.MicMute:bindHotkeys(binding)

```

You'll have to add the MicMute spoon which just mean downloading the zip here, unzipping, and opening the .spoon. https://www.hammerspoon.org/Spoons/MicMute.html

The quote at the bottom is great:

You can have a second computer once you've shown you know how to use the first one.

-- Paul Barham, quoted in the COST paper

Followed by a quote from Pink Floyd's _Another Brick in the Wall (Part 2)_.

_Stand still laddie!_

This doesn't seem particularly formal. I still remain unconvinced reducing is really going to be valuable. Code obviously is as formal as it gets but as you trend away from that you quickly introduce problems that arise from lack of formality. I could see a world in which we're all just writing tests in the form of something like Gherkin though.

> I could see a world in which we're all just writing tests in the form of something like Gherkin though.

That works great in practice, Gherkin even has a markdown dialect [1].

If you combine it with a tool like aico [2] you can have a really effective development workflow.

[1] https://github.com/cucumber/gherkin/blob/main/MARKDOWN_WITH_...

[2] https://github.com/jurriaan/aico

People seem weirdly eager to talk to LLMs in proto-code instead of fixing the base problem that LLMs are just unreliable interpreters. If your tool needs a new human-friendly DSL to avoid the ambiguity of plain English, maybe what you really want is to be writing actual code or specs with a type system and feedback loop. Any halfway formalism gives a false sense of precision, and you still get blindsided by the same model quirks, just dressed up differently.

> I could see a world in which we're all just writing tests in the form of something like Gherkin though.

Yes, and the implementation... no one actually cares about that. This would be a good outcome in my view. What I see is people letting LLMs "fill in the tests", whereas I'd rather tests be the only thing humans write.

> Yes, and the implementation... no one actually cares about that.

There has been a profession in place for many decades that specifically addresses that...Software Engineering.

While I'm also a bit skeptical, I think some formalism could really simplify everything. The programming world has lots of words that mean close to the same thing (subroutine, method, function, etc. ). Why not choose one and stick to it for interactions with the LLM? It should save plenty of complexity.

These studies are always really hard to judge the efficacy of. I would say though the most surprising thing to me about LLMs in the past year is how many people got hyped about the Opus 4.5 release. Having used Claude Code at work since it was released I haven't really noticed any step changes in improvement. Maybe that's because I've never tried to use it to one shot things?

Regardless I'm more inclined to believe that 4.5 was the point that people started using it after having given up on copy/pasting output in 2024. If you're going from chat to agentic level of interaction it's going to feel like a leap.

I used it with Sonnet 4.0 a lot, and there was vastly more back-and-forth and correction of "dumb" things, such as forgetting to add "using" statements in C# files.

I don't know if it's model, or harness improvements, or inbuilt-memory or all of the above, but it often has a step where it'll check itself that is done now before trying to build and getting an inevitable failure.

Those small things add up to a much smoother and richer experience today compared to 6 months ago.

Nah, pre 4.5 it was not comfortable to use agentic coding.

Isn’t this what World Coin is? Definitively not a fan of the project but I think the general goal is to get people to verify they are human and then somehow “waves hands blockchain” that can be carried with them on the internet.

Grifting is about as American as apple pie honestly. Melville is of course know for Moby Dick where he delves into the psyche of the Great American Man but he also wrote The Confidence Man. Mark Twain’s work is full of con men and grifters. Ponzi laid the groundwork for more complex schemes in the 20s. Pyramid schemes were all the rage in the 40/50s, Tupperware parties as an example, and of course still are huge today.

It seems like whenever American society is changing very rapidly or has changed very rapidly con men become the powerful ones of the time. Maybe this is true everywhere but as an American I don’t know the history of cons in other countries.

I’m still waiting for someone to build a good lisp harness. Stick an agent in a lisp repl and they can change literally anything they want easily.

I've been thinking of doing the exact same thing. Preserve context as images and die. Expose a single tool called "eval". You could have a extremely tight editor integration using something like SLIME.