If they’re equivalent, why do you need the compiler?
Maybe I’m biased as a compiler author, but it seems to me that the compiler is doing quite a bit of valuable work that most human programmers can’t or won’t do on their own.
For instance, I’ve spent a lot of my own time improving ZILF’s code generation, poring over assembly listings and feeling pain in my soul whenever I see an opcode that doesn’t need to be there. And I’d be annoyed if someone pointed to the resulting sleek, supple, instruction-level beauty of their compiled ZIL game as evidence of their optimization rather than mine.
Edit:
No one is asking you to believe that LLMs are “equivalent to compilers”. As I wrote earlier:
The purpose of an analogy is not to imply that two things are identical in every respect, but to highlight the respects in which they are similar. In this case, the respect in which they’re similar is that they’re ways that machines produce code instead of humans.
I’m skeptical that this thread has a single coherent topic, but I think the question was whether “Human Made” or “No AI” is a better/clearer term.
The question is not whether LLMs are “equivalent” to compilers (morally or functionally), or whether compilers are “valuable” or not. (Obviously compilers are valuable.)
I think “No AI” or “No LLMs” is a better/clearer term than “Human Made”, not because LLMs are “equivalent” to compliers, but because there are a bunch of totally unobjectionable non-human code generators.
I think it’s confusing to try to define the non-human code generators that are allowed to be called “Human Made.” Like, what about pre-LLM IntelliSense? Or pre-LLM automated refactorings? (“Extract method”, “Rename function”, etc.?) Or linters that can automatically fix code-style issues?
It’s not just whether the output is deterministic; pre-LLM IntelliSense autocomplete wasn’t always deterministic, but it wasn’t scraped from unlicensed source material, it (normally) ran locally to your machine based on a trivial usage of computing power and electricity.
IMO, the reason people care about a “No AI” label is that they have mostly moral objections to LLMs, and so saying “No AI” or “No LLMs” makes it clearer what you’re saying didn’t happen, rather than making an ambiguous “Human Made” claim, leaving it open to interpretation what you consider “Human Made.”
Agreed. And my take would be that “Human Made” could still allow the use of AI, since it’s up to the human. For example, I craft all the narrative of a game myself, but I have AI help me sort out some puzzle mechanics. Then I recrafted what it did by hand. Maybe in one case I had AI generate code; in another, I didn’t (just ideas I could implement in code). So, to me, that’s “human made,” but AI-assisted in very limited areas. And note that’s only code. What if I had Grammarly (which uses an AI) to help me with my grammar? What if I had AI suggest some better wordings for things (similar to how I would consult a thesaurus)?
I’m not trying to be pedantic, but “Human Made” is already something people apply to their code or non-code, even when AI was used to assist. And this is because people draw a line between assist and create. And they tend to draw that line in different areas.
In that way, “No AI” is much clearer – assuming everyone agrees it means “absolutely no AI of any sort was used or consulted for anything at all.” But as upthread showed, some people do have some tolerance for AI; just not in areas they consider quality- or human-degrading. Once it can mean “No AI (for the important bits, but was used for some of the other bits),” that’s where the discussion inevitably goes into the alleys it went to in this thread. I see this on LinkedIn literally every single day in my professional context.
Compilers perform (if they’re written well) fully deterministic mechanical transformations on high level code into lower level code. Those transformations are reasoned, predictable, and repeatable giving a 1-to-1 mapping from source to output. That mapping only changes when a compiler is updated, which is a choice under the developer’s complete control. They provide a sort of computational leverage little different than using a hammer to pound a nail instead of your fist.
Regardless of guardrails I would argue none of that applies to what an LLM does, even with a constant AI environment/model (no fluctuating cloud component). An AI choosing to implement an algorithm based on some user-stories and descriptions is vastly and qualitatively different than a compiler taking a developer written algorithm in a high level language and optimizing it for a particular piece of hardware or unrolling a loop. To stretch the carpentry simile, it’s less like pounding a nail and more like saying “Here’s some nails and boards. My house should look like…”
None of that even considers negative things like enviornmental impact, bias and misinformation, data harvesting and spying with the resulting concentration of power, destruction of physical books after copying (looking at you: Anthropic!), economic inequality, unauthorized use of copyrighted information for training (which is rich considering how aggressively the AI companies pursue those same laws against everyone else), and as always: eventual enshittification.
I agree, but again, how does that make it acceptable to claim the compiler’s work as your own?
Maybe I should know better than to try to use an analogy on the internet, but I think it’s pretty explicit by now that we all understand LLMs and compilers are not the same in every respect. My claim is that they have this one aspect in common: they are ways for machines to produce code instead of humans, and thus it’s dishonest to claim their output is “human-made”.
Even the idea of determinism vs non-determinism is problematic. One can argue that C++ is, for all intents and purposes, non-deterministic. The determinism of the language is largely controlled in 2 eras, pre-standardization and post-standardization. You can make the argument that in the current era, it is possible to write code, that compiles and runs, decompile it, and the resulting source is not equivalent in function. A simple example would be the following program: int i = INT_MAX; if (i + 1 < 0) printf("overflow"); Before standardization this was fine. After it is considered undefined behavior. One runs and prints “overflow”, one doesn’t do anything. This behavior is opt-in by default and you have to opt-out to get the pre-standardized behavior.
On an objective level, @Draconis is talking about a 1-to-1 relation of the input to the output in the end product. The same syntax produces the same compiled code, which leads to a philosophical discussion about authorial intent.
Because LLMs are not 1-to-1 on input to output, they introduce anomalies… and one can make the argument that these anomalies are not conceived from the human author (and whether they are beneficial or not is beside the point).
Because the compiler doesn’t write anything, it merely translates following a fixed set of rules. Rules which may leverage knowledge gathered by countless others during their development, but which are still purely translational. LLMs don’t do that. If they did they’d just be compilers. A carpenter who uses a high quality tool to produce superior work is likewise leveraging the experience of many, but it doesn’t mean the product is any less “human-made”. That same argument does not apply to LLMs. Yes they are tools, impressive ones at that, but they are not merely translating work or providing leverage. To extend the carpentry simile (again), LLMs are more like feeding a vague description into a CNC machine or 3D printer.
Seeing as how this started as a “Developed without AI” thread, I’d like to point to a thing that r/programming did recently. Their users were so exhausted with AI arguments that they ran a short term test of a complete moratorium of discussion about AI/LLM. The test went over favorably and resulted in a new permanent policy, which I’ll share here. This is not the complete policy, but I think it gets the intent across.
# The motivation
r/programming’s content has been dominated by discussion of AI/LLM to an extent that its users are fatigued at a lack of any other content.
AI and LLM tools are sweeping professional software development in a way that is dominating online discussions. Additionally, it’s dominating *other* fields in a way that’s bringing attention to previously programming-exclusive topics like machine learning. As a result, r/programming has gone through multi-day periods where its front page is dominated by reviews of coding assistants, discussions of whether programming as an industry is “over”, and even fully off-topic posts such as lawyers being sanctioned for trusting AI hallucinations in court. It’s gone on so long that we trialed [a complete ban](https://www.reddit.com/r/programming/comments/1s9jkzi/announcement_temporary_llm_content_ban/) and got [overwhelmingly positive feedback](https://www.reddit.com/r/programming/comments/1t4odyl/looking_for_feedback_on_ai_content_in/) on it.
We’re not claiming that talking about AI isn’t programming, or sticking our heads in the sand and denying the future, or just being doomerist anti-AI luddite fuddy duddies. But there is no mechanism by which the Reddit platform allows us to say “up to 10% of content per day can be AI” so this is the only flood control mechanism we have.
Ivan that sounds like a clever idea. Even more so as no one is convincing anyone, making this a fruitless discussion, even with clever points made on both sides.
Made With AI - meaning AI tools were used in development
vs
Made By AI - vibe coded
vs
Made Without AI or Made By Humans - no AI (or very little AI used for reference in the same way that a Google search might be, because realistically it’s becoming almost unavoidable)
Indeed. My understanding is that the nondeterminism of an LLM is a parameter that can be controlled by the developer using it: turn the temperature down as far as it will go, and the same prompt will give you the same response every time (at least for some models). ChatGPT et al. introduce nondeterminism as a product choice, not an inherent part of the technology.
That’s not 1:1 relation, that’s nondeterminism (about which see above). A compiler with a 1:1 relation between input and output is more of an assembler. A typical compiler will do some amount of reinterpretation of your input to produce output that functions the same but works differently, applying knowledge and heuristics that were put there by its creators rather than the user.
In a pedantic sense, the compiler is merely applying rules to translate input to output, sure – but then, in that sense, so is an LLM. Tokens go in, rules are followed to shift a bunch of numbers around, tokens come out. Given the same parameters (see above) and the same input, you’ll get the same output, because math is math. The real difference is that most of the “rules” an LLM follows arose through training instead of being intentionally designed.
I still don’t see how “the compiler just follows rules” leads to the conclusion that it’s acceptable to claim the compiler’s output as your own, though. Did you, the user, follow those rules yourself? No. Do you even know the rules it’s following? Probably not – I certainly don’t know everything GCC or the C# compiler are doing, and after 17 years of development, I couldn’t even tell you everything ZILF is doing without checking the code. So in what sense is it your work?
And I would say that a compiler is more like a CNC machine or 3D printer than a hammer, in the sense that it enables you to do things that you typically wouldn’t be able to do without it, and it does that using mechanisms you didn’t design and are likely unaware of.
@Ivan Several participants in this thread mentioned making a distinction, in one way or other. I think that makes really sense.
I think I could live with games which are made with a bit of help from AI. But I still prefer to know ahead whether it’s made with AI or not, so that I have the chance to decide myself if I am going to play slop or not. So I appreciate any label. Fortunately the big games sites seem all to have such a label.
I think this might be where a big difference lies. In a compiler those rules directly pertain to translating code from one form to another with decisions baked in about hardware, etc. In an LLM the rules under which it operates have essentially nothing to do with the task at hand and therefore its code generation is kind of a second-order byproduct of those rules. It isn’t constrained by a formal system like the compiler is and the code is more an emergent behavior of the underlying probabilistic relationships in the training data.
I’d be interested to know two things about a text adventure game – whether the story was written with AI involvement, and whether the code was written with AI involvement. It would be good to know some detail about each.
This all reminds me about another controversial debate – content/“trigger” warnings…!
Writing machine code by hand is akin to producing a handwritten manuscript. Labor intensive, time consuming, and arguably involving a lot of effort that has little to do with the essence of writing a novel/program.
Using a compiler is akin to submitting a typewritten manuscript to a printing press. The core creative part of the process is still done by a human, but the mechnical part of the process is handed off to a machine.
Vibe coding is akin to having an AI write a novel… and this might be where the analogy breaks down, because it’s hard to give compilers a level of credit they deserve while leaving room on the non-programming side of hte analogy to avoid comparing AI to itself…
Still, it’s hard to imagine someone discounting a novel as human written just because we’re talking a mass market paperback instead of a handwritten manuscript, though we do make a distinction between handmade and mass produced. Still, just as most people don’t care if the book they are reading is a handwritten manuscript or a mass market paperback and only the rich could afford the manuscript regardless, even fewer care whether a app was written directly in machine code or compiled from higher level code… and insisting all software be written directly in machine code would just make programming harder, more labor and time intensive, require higher prices to be profitable, and make it harder to write featureful code… The machine code is machine generated, just as the mass market paperback was made by a machine, but the source code was still human written, and that’s what most people care about.
As for decompiled code not being identical to the original source, to stretch the analogy further, the decompiled code is akin to a transcript of a published book, but the original source is not only the original text, but all of the author’s private notes that were omitted when the book was printed.
I can buy the LLM is a sort of compiler argument. The prompts are the source code.
Under copyright law, at least, the output of a compiler belongs to whomever holds the rights to the source code, presumably the author. However, the output of an LLM is not copyrightable although the prompts certainly are. Under that definition of ownership, there is a clear distinction between compilers and LLMs. People who vibe code systems and/or IF works don’t actually own the stuff they make.
You are confusing the process of compilation with the predictability of compilation. When I say 1-to-1, I speak of the predictability. Having the same syntax repeatedly producing the same compiled code structure is about as deterministic as it gets.
I hope you can now contend with the sentiment of what is being said.
You’re right, I meant to say “determinism”. Fixed.
I stand by the rest of my response: LLMs aren’t inherently non-deterministic, so if repeatability is what you want, you can have it. But does turning the temperature down on an LLM make its output “Human-Made”? I don’t think so.
If you mix some ingredients and put them in the oven, does that mean the resulting product is not “human made” because the final product was actually created by the oven?
EDIT: To very slightly clarify my haphazard metaphor, the oven is the compiler. Neither an oven nor a compiler claims to have agency. But also, much like an oven, the LLM does not work very well if you turn the temperature down to zero.