Abstract

Generative AI systems that turn natural language prompts into working code are often described, loosely, as compilers: programs that translate one language into another. This essay argues that the analogy fails not because of a technical limitation, but because compilation carries a specific guarantee of determinism (meaning preserving translation against a fixed formal specification) that natural language by its underspecified nature cannot supply. Working through compilers, transpilers, interpreters and the constrained case of natural language to SQL translation, the essay argues that what GenAI for coding actually do is structurally identical to historical interpretation of constructing the most plausible meaning from evidence that underdetermines a single answer. It proposes a name for this activity that has, so far, gone unnamed in computing: the hermeneutor.

1. A Question That Looked Simple

The inquiry began with a deceptively ordinary question, "if a generative AI system can turn a plain English request into working code, does that make it a compiler?" A compiler is commonly defined as a program that translates one language into another, and turning "build me a login page" into a working program certainly looks like translation from one language i.e English into another i.e a programming language.

The temptation to answer yes is understandable. But working through the question carefully, testing it against what a compiler actually guarantees, then against transpilers, then interpreters, then finally against an entirely different domain, historical scholarship, reveals that the concept being described has no adequate name in the existing vocabulary of computing. This essay reconstructs that reasoning and arrives, by the end, at a proposed word for the missing concept: the hermeneutor.

2. What a Compiler Actually Promises

A compiler is not merely a translator between two notations. It is a translator bound by a specific, load bearing guarantee: semantic preservation against a formal specification. Every valid program in a language like C++ has exactly one meaning, defined precisely by the language's grammar and semantics. The compiler's entire discipline, parsing, type checking, optimization, and code generation, exists to carry that one meaning across the gap between human readable syntax and machine executable instructions without altering it. Compiler correctness is a mathematical property: an optimization is only valid if it can be proven not to change observable program behavior.

This is the detail that natural language cannot supply. "Build me a login page" does not have one precise, agreed upon meaning the way int x = 5 + 3; does. It is underspecified by design; it relies on shared context, convention, and the listener's judgment to fill in a password policy, a framework choice, a data model, none of which the sentence itself determines. A system that resolves that sentence into code is not preserving a preexisting meaning; it is constructing one. That distinction, preservation versus construction, turned out to be the hinge on which the entire inquiry would turn.

3. Determinism Is Not Enough

A natural follow up sharpened the question: what if the AI system were made perfectly deterministic, same prompt, same output, every time? Would that qualify it as a compiler?

The answer is no, and the reason is instructive. Determinism describes the behavior of the translator; it says nothing about whether there exists a fixed, agreed meaning being translated. Two different people phrasing "the same" request in different words could still, entirely reasonably, expect or accept different valid programs in return, not because the system misbehaved, but because the request itself never pinned down a single correct answer. Compilation requires both determinism and a formal specification the translation is provably faithful to. Removing the second requirement while keeping the first produces something real and useful, but it is a deterministic translator, not a compiler.

4. The DSL Escape Hatch, and Its Limits

The inquiry then turned to Domain Specific Languages: SQL, regular expressions, HTML, Excel formulas, narrow, purpose built languages that trade generality for precision. This surfaced a genuinely productive idea: perhaps natural language could be compiled deterministically after all, provided the target language is narrow enough. "give me all columns from the employees table" and "from employees table select all columns" are paraphrases, not ambiguous statements; they both resolve, unambiguously, to SELECT * FROM employees, because the target grammar, SQL, is small, closed, and finite. A system could even ask clarifying questions when information is missing, much as a compiler throws an error on an incomplete program, an approach that closely mirrors real research in interactive and clarification based semantic parsing.

This is a legitimate result, but a bounded one. It works for SQL because the space of things that could be missing, which table, which columns, which filter, is small and enumerable, like the parameters of a function signature. It breaks down the moment the target is something like general purpose application code or a judgment call like "process refunds fairly," where the number of unstated details is not small or enumerable at all. The clarifying questions strategy that rescues determinism for SQL does not generalize, because what makes it work, a fixed, closed target grammar acting as a scaffold for disambiguation, is precisely what is absent in the open ended case.

5. A Detour Through History

To locate the missing concept, the inquiry left computing altogether and asked about historians: when two scholars examine the same documents and draw different, both defensible conclusions, what is that called? The answer is interpretation, formalized in the discipline of hermeneutics, the theory of how meaning is drawn from a text or body of evidence when the evidence itself does not fully determine a single reading. The historian's activity is not deduction from certain premises but inference to the most plausible explanation, and "most plausible" is a judgment, which is exactly why competent historians can diverge.

This detour mattered because it exposed the real shape of the original problem. Generating code from a vague prompt and reconstructing a historical narrative from incomplete documents are, structurally, the same act: reasoning from evidence that underdetermines a unique conclusion, and filling the gap with judgment rather than proof. Neither compilation nor transpilation names this activity, because both of those terms describe meaning preserving translation between two already fixed formal systems.

6. Two False Leads: Transpilation and Interpretation

Two existing computing terms were tested and set aside. Transpilation, source to source translation, as in TypeScript compiling to JavaScript, was ruled out because it is, like compilation, deterministic and strictly meaning preserving; both sides of a transpilation are already formal languages with fixed semantics. Nothing is being resolved or judged; only notation changes.

The word interpreter proved more tempting, since ordinary language already has "interpretation" doing exactly the work described above. But this turned out to be a false cognate. A computer science interpreter, the kind that runs Python line by line, is fully deterministic and meaning preserving, exactly like a compiler; it merely defers translation until execution time rather than doing it all upfront. It does not exercise judgment about what code might mean. The computer science sense of "interpreter" and the humanities sense of "interpretation" share a common English root but denote unrelated concepts, one of the more useful discoveries of this inquiry, since it explained why reaching for "interpreter" felt right and was nonetheless wrong.

7. Hermeneutor

With compiler, transpiler, and interpreter all excluded for the same underlying reason, each requires a fixed, preexisting meaning to preserve, the conclusion followed naturally: the concept in question needs its own word, not a stretched borrowing of an existing one. Following the same morphological pattern that produced translator, interpreter, and compiler, a practice or verb plus the agent suffix -or, hermeneutics yields hermeneutor: one who interprets, one who resolves ambiguous or underdetermined input into a meaning or output by judgment, rather than by mechanically applying a fixed, unambiguous rule.

The table below summarizes where the term sits relative to its neighbors.

Under this scheme, an LLM turning a vague prompt into code is a hermeneutor. A historian turning archival documents into a narrative is a hermeneutor. A natural language to SQL system operating within a narrow, closed schema is not; it remains a deterministic translator, because the DSL supplies the missing formal structure that would otherwise require judgment. The same system aimed at open ended, general purpose output crosses back into hermeneutor territory, because no fixed grammar remains to disambiguate against.

8. Conclusion

The value of this exercise was not in relabeling generative AI, but in exposing what the words already in use quietly promise. Compiler, transpiler, and interpreter all encode the same guarantee, a fixed meaning, faithfully preserved, inherited from decades of formal language theory. That guarantee is precisely what natural language, by its nature, does not supply, which is why every attempt to fold generative translation into those categories eventually strained against their definitions. Naming the actual activity, judgment based resolution of underdetermined input, as hermeneutor rather than compiler is not a semantic technicality. It is an honest acknowledgment of what the tool is actually doing: not preserving meaning, but constructing the most plausible one, the same way a historian does, and for the same underlying reason.