The author questions whether large language models (LLMs) can truly function as compilers, given their tendency to hallucinate or produce unreliable outputs. This evokes a long-standing debate in computer science about the evolution of programming languages. As LLMs improve, they could potentially offer reliable implementations based on natural language prompts. However, the author argues that programming inherently requires precise specifications, and LLMs might struggle with this due to the vagueness of natural language. Programming involves making a computer perform tasks through a series of exact instructions. Higher-level programming languages abstract away the complexity of lower-level operations, allowing developers to focus on logic rather than bit manipulation. This abstraction comes with a trade-off: programmers give up some control, which raises concerns about the reliability of those abstractions. The relationship between user specifications and actual program behavior becomes murky, especially with LLMs, which may generate multiple valid interpretations from a single prompt. The author emphasizes that the lack of precise semantics in natural language makes it difficult to ensure functional correctness in LLM-generated code. Unlike traditional programming languages, where behaviors are well-defined and testable, LLM outputs can be underspecified. This creates risks, as vague requirements can lead to unintended consequences when an LLM generates code. If a user asks for a note-taking app, the LLM’s interpretation could vary widely, producing something that may not align with the user’s actual needs. The potential for misalignment between intention and outcome becomes a significant concern in this context.