LLMs, Brahma, and one-way doors

My grandfather used to often use the phrase “only Brahma can undo Brahma’s knots”. The context most often would be when he would have misplaced something while attempting to “stow it away carefully”.

This maxim applies in several different contexts - for example, in the pre-LLM era, one could say that the bugs introduced by a particular programmer could only be undone by the same programmer. If someone got you into trouble generally, you needed the same person to get you out of trouble.

Now, in the era of LLMs, this takes on a whole new meaning. Basically two ways in which LLMs are like Brahma:

• Once a particular program has been vibe coded, it will forever need to be vibe coded. It is next to impossible for an unaided human to understand the code and take it over

• Any document written by an LLM can only be read by an LLM (either the same one or another)

Basically, the uniting thread here is that when a large language model writes any kind of language, a lot of it can only be read by other such language models!

At this point I got disturbed while writing this. What follows was written at least a month later.

And thinking about it, what makes both AI-written documentation and AI-written code unreadable for humans is that they are way too verbose. AI lacks brevity. Rather, unless you explicitly ask for it to be concise, it isn’t concise (either in natural language or code). And this feature (bug?) of AI means that in a lot of contexts, using AI becomes a one way door.

The thing with both AI-written code (i’m only talking about entirely vibe coded repos here, not stuff where things are initially human-written, and AI is only an “assistant”) and AI-written documentation is that there is no incentive for the AI to be concise.

I wonder if this has to do with how we “fill in information as we read” - when a human writes for a human, it is common to leave some things unsaid, with the expectation that the reader can reasonably fill in the details. However, an LLM doesn’t work like that. While it can “fill in details based on its knowledge”, these details are usually not the same as what a human would fill in in the same case.

So, when an LLM writes, it plays safe. It assumes that the reader may not be able to fill in the precise details, and so it packs the documents with details.

LLMs also do this when writing to us humans - how many times have you had to tell ChatGPT (or have it in your claude / codex system prompts) to “be concise”? A lot of times, LLM writing is pretty unreadable (even in chats) because it is so verbose.

As an aside, on a LLM-focussed WhatsApp group that I’m part of, someone posted this prompt to make LLMs “ADHD friendly”. I haven’t tried it out yet, though I use this other skill called “caveman”.

On the coding side, I think LLMs write verbose code because they can very easily read verbose code. I mean, one reason humans code (relatively - impossible when writing Java for example) concisely is for vanity reasons - people of my generation used to write “nested ternary (?: for ifelse) operators” in C. And another is that if the code is too verbose, you won’t feel like reading it later.

LLMs again have no such constraints. Since they are basically math models processing large matrices, they don’t “suffer from NED”! And so a 100 line program is as easily readable for them as a 1000 line program. And so they don’t bother being concise.

In any case, the upshot of all this is that LLMs are like Brahma - once they have touched some content (either natural language or code), it is a one way door. Only LLMs can deal with it henceforth.

Have you found any ways in making LLM-produced output more human-friendly (apart from things like writing skills, of course - I use that extensively)? If so, please share.