So the LLM would have done all of this on its own? Why is it ok to acknowledge the human was needed but it’s not a collaboration? Is there a defined percentage of ownership required to make the word collaboration valid?

We focus on the tool because that is what makes it novel.

Hearing a guy built his home in a week with the power of nails and a hammer would have been novel in era of mortise and tenon.

I actually found an article about raving about how fast nail production was thanks to machining advances in 1790 and that it would bring great value: https://digital.libraries.psu.edu/digital/collection/pabookn...

It’s seems to me humans haven’t changed, just which machines we praise.

If you get someone to build you a house and they do it on their own, does that not count because they wouldn't have done it if you didn't pay them to do it?

Technically you built it yourself and the builder was just a minor collaborator?

Correct. I do everything by myself.

I appreciate the effort that went into the verbose version of the "I made this" meme for an hn audience.

From the article:

"However, the most astonishing thing about this break is that the GPT–6 Astra did it entirely on its own. Carter Leffer only directed GPT–6 Astra to see if it could break any of the unbroken Enigma messages published on the Crypto Cellar Research web page."

I mean... I'm all for collaboration but I think this case is pretty clear, no?

I mean, the LLM could do it even without all the HUMAN knowledge that was stealed during training about the Enigma machine?

We are fooling to me, there is no intelligence in these models, they just apply methods that were invented by humans without any consciousness on what they are doing.

You could say exactly the same about humans. Ex nihilo nihil fit. Every human depends on a vast corpus of prior human knowledge to be able to accomplish anything. This doesn't mean they have no intelligence.

At the margin innovation is just taking the obvious next step first.

Says the person whose never produced a novel thought in his life!

English isn't code. Come on.

It is much closer now. Just like how C/C++ devs used to say "JavaScript isn't real code" or "Python script kiddies". Code was literally designed to be just easy enough for people to understand, now it's just even easier to understand.

It is not yet the same as C++ or Python, for two reasons:

1) Ambiguity is still the default. Formal languages force you to resolve it up front.

English lets you paper over it until the model or the compiler (the human) notices.

2) The "compiler" (the LLM) is statistical and non-deterministic. Same prompt, different day, different bugs. A real language has a spec.

The practical move is to treat English as a high-level specification language, keep the generated artifacts inspectable, and "still know enough of the lower layers to notice when the translation went wrong."^1

[1] This is the key that is where humans can still be necessary, or at least another pass through the LLMs to decide on the best path, in the compiled code. Compilers for other languages do the same C -> Binary, etc.

A conventional compiler is bound by an as-if rule. It can take many internal routes, but the observable behavior has to match the language spec. Same source, same defined semantics. If two gcc runs emit different binaries, the program is still supposed to compute the same answers on the same inputs. That is why people treat the source as the artifact and the binary as disposable.

An LLM compiling English has no as-if rule unless you add one. "Sort the users by last active" can become a stable sort, an unstable sort, a SQL order by, an in-memory timsort, or a query that drops people with null timestamps. All of those can look like success. They are different programs. The model is not optimizing under a spec. It is filling in the parts you did not write.

A human who can read the destination language still notices when the chosen path is the wrong program.

A second model pass can compare paths, but only if you give it a way to score them: tests, types, invariant

So the historical analogy still holds, with one correction. JavaScript and Python were dismissed for being too easy, but they already had grammars and evaluators. English is easier still, and the evaluator is a statistical translator that will invent a dialect if you let it. The practical move stays the same: treat English as the spec language, pin the generated artifacts behind tests, and keep enough fluency in the lower layer to see when the translation chose a different program than the one you meant. The human is not required because the computer is weak. The human is required because the source language still leaves room for more than one destination.

The difference is that those C/C++ devs were wrong. Claiming Javascript isn't code is just wrong. Even claiming HTML isn't code is wrong. How is it much closer now? Did English evolve to be more like code, or did code become more like English? And I'm not talking about how Python is more English-like than 6502 Assembly, I mean in the last few years.

English is not code just because a technology was developed that could make educated guesses based on being trained with other code that people have written as to what the code generated should look like.

Also, much of this reply looks LLM generated.

A cyclist pedaling up a mountain isn't a "collaboration" between a bicycle and a human. This is the same. You don't see feral bicycles roaming the land. All models are ultimately built and run by humans, with human-provided instructions. And as with any program, it's garbage in, garbage out.

More apt analogy here: a cyclist pushing a bicycle down the mountain and seeing it somehow get down the whole track without falling down, is not a collaboration between a bicycle and a human. The human was not involved beyond giving the initial push.

If I told you to pick an encrypted message from the web site and decrypt it, and you went and did it with no further input from me, would you okay with me calling it a collaboration to decrypt the message?

The bicycle -- a simple method of transport powered entirely by humans -- used analogically to prove a point about [clears throat] automation.

I think this sounds somewhat less silly in English because "automotive" and "automative" don't have the same hyper-visible affinity, but all the same; you may want to consider the car as a more viable analogand.

What do you even mean it wasn't a collaboration. At any meaningful level LLMs just plain out suck when left unguided.

The shortcomings should really be obvious by now to anyone honest. And the marketing distortion being oushed out is just tiresome and detrimental for all of us.

What's tiring is the constant snide dismissiveness of the advances in technology by people who don't even RTFA, but yet show up on every AI thread and spout the same nonsense.