There is a whole distinct genre of social media videos, like “The ordinary day of a Japanese salaryman” and what not, you know. So here is mine.
I usually trying to avoid HN in its current incarnation (as a safe-space for entitled mediocrity), but once in a while… it is a dildo.
https://arkaung.github.io/interactive-turboquant/ – I have seen this shit before, a lot of it. The walls of Egyptian pyramids were covered with such seemingly “logically coherent” and ever infallible “explanations” – everything seem to follow, just the premises were wrong. Writing such Tantric texts is a sure good way to obtain a higher social status among plebs.
There is a catch – all the multi-dimensional gibberish is just abstract bullshit interpretations . The actual algorithms used for the actual inference (actual slop production) are based on the notion of a conditional probability – the most probable next token, given the previous “state” . No higher dimensions in principle.
There is another one – when the actual algorithm is selecting the very next token, if we “take a snapshot of a whole process and visualize it”, what we would see is not higher dimensions, but a good old friend – a DAG – which branches for each possible next token (there are even 3Brown1Blue videos on youtube). This is a crucial point – at every level the outcome is a weighted sum, which can be seen as a join of all the input arrows (weights).
But you see, how much unique snowflaky one would appear if one instead of dealing with plain and boring forks and joins, produce a fancy pseudo-intellectual gibberish about absteact (non-existing even in the actual computer memory) higher dimensions, and this is exactly what they do.
And just right below on thr top NH page is another one – https://github.com/evanklem/evanflow
Look, HN, how fucking smart I am! I am about to apply TDD practices to AI slop! No one have ever thought about this before, and there is already my github repo. Amazing, isn’t it?
Let’s try to imagine and understand, at least intuitively, what would happen in reality.
Yes, it would be absolutely wonderful to somehow pour “eXtreme Programming Explained”, “Test Driven Development by Example” and, perhaps, “Modern Software Engineering” in, and get some code out. Just imagine feeding in the Barbara Liskov’s books instead, or “ML For Working Programmer”, but till.
Now pay attention – any human language is in principle inherently sequential – “the cat eats dog is not the same as dog eats cat” and all that crap. The training process is sequential (but paralleirized) and the inference process is sequential (given the previous sequence and the global state).
So, placing good, proper “keywords” in a prompt is already a big deal – having mentioned “TDD” would ‘fork’ you (branch out) into whole different region of the DAG than not having it. Having a bunch of such keywords would, probably (at least n theory) branch out into a region of professional code, instead of amateur crap from Github. Notice that the ordering matters a lot, as well a correct grammar in prompts.
In theory an LLM can even produce some parts of the classic tests verbatim (of course, they trained on the pirated copies of the books, otherwise it wouldn’t even work as it appears to be). But hey, most of the code examples in the classic XP/TDD books are in fucking Java, are about Java, what if your prompt and your context said Rust or Haskell.
The model would “jump” to the most probable token, given “Rust” (instead of Java)… but where to? Definitely “out of the book region”, but where?
There is much more to this. The autocompletion of the code is a much easier task since the core has order of magnitude lower branching factor (this is why even the crappiest models could produce something coherent), so once the context has a few correct tokens in a sequence it will “unfold” a whole code block verbatim (the weights are all “stand out”)..
But from where is the code came from? Does it actually related to the slop already generated so far (and put back into the context)? Not at all. This is exactly how the models are “lying” to you. They got a solid theoretical verbiage from one region, and then generated whatever they happen to “jump in” in this context.
This is exactly how the cognitive illusion work – everything seems coherent and convincing, unless you are a real expert and can actually validate the slop and trace it back to the first principles. and then re-derive from them. This is how one spots a lie.
So, yes, the idea to convert rare good books into “skills” (squezing out the water and narcissistic monologues) was an old idea, the only problem is that the slop generators does not work that way, neither in training, nor in inference.
What you would always get is an appearance, an illusion – the right wireds in the relight order, but the code is subtly disconnected or subtly unrelated to the accompanying verbiage. I have a lot of Rust code prompted form the first principles, and it is all crap (but way bettern that what is on Github), simply because it just cannot.
Notice that this is not “hallucinations”, it is the hard ceiling of capacity – they cannot synthesize or reason in principle, there is nothing in the actual algorithms which can do it.
But yes, one can generate a way, way ,more convincing slop and more entangled, complicatedly structured “over-enginered” code, which would appear as if it is consistent with the accompanying verbiage and especially the fancy prompts and these skills (which are, after all, just additional sequence added to the context).
Okay, enough for today.