The Problem of the Human-Computer Interface and Why LLMs are not the Solution
03-01-2026 — Adam Schaefers
How computer programming actually works
The CPU must be spoken to in a language it understands, that is represented in binary. Hence we have executable files, called binaries, that are computer programs compiled down to cpu-native computer language.
And so it follows that we use higher level intermediary computer programming languages, such as C, to interface with the CPU, where then we run our human-readable (yet precise) code through a compiler to produce the executable binary for the CPU.
C ironically used to be considered a high-level programming language, but now is often considered "low-level" because we have languages with syntaxes that are even easier to read, such as Python. Python, moreover, does not require an ahead-of-time compiler to generate a native executable, but instead provides a bundled interpreter, which compiles Python code into bytecode and executes it via a virtual machine, while also handling more complex subjects like memory management.
When given the same implementation, same version, same configuration, and same environment In the case of the interpreter or of the compiler, both produce the same result, every single time when presented with well-defined code in the programming language.
Hello, -name- (in C)
Here is a small program in C that when compiled and executed, prints "Hello, Adam!"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void)
{
char *name;
char *msg;
size_t n;
name = "Adam";
/* "Hello, " + name + "!" + '\0' */
n = strlen("Hello, ") + strlen(name) + strlen("!") + 1;
msg = (char *)malloc(n);
if (msg == NULL)
return 1;
sprintf(msg, "Hello, %s!", name);
puts(msg);
free(msg);
return 0;
}
Hello, -name- (in Python)
Here is a small program in Python that when interpreted, also prints "Hello, Adam!"
#!/bin/python3
name = "Adam"
msg = f"Hello, {name}!"
print(msg)
The Python version, being higher level than the already high-level C language, immediately takes a performance hit. The code executes much slower, as it must be translated by the interpreter and all of the extra stuff that a Python program must do as discussed in paragraph 3 above.
While the Python version is also much easier to read and accessible to more humans by default, with less training required to get started and programming. For this reason, Python is often recommended as a great first programming language choice for a learner.
Other than some tradeoffs we noted, both programming languages are well defined, and their programs above are well defined, such that they both do the same exact thing, every single time.
Hello, -name- (in English)
Here is a small LLM program in English that prints "Hello, Adam!", but oddly refuses to print "hello, Adam!" or "hello, adam!"
The result as shown, is only 1/3 responses from ChatGPT were technically correct with the precision I was looking for. The ambiguity of English is such that, I presume the bot assumed I wanted correct capitalization grammar, but how can it know for certain without guessing?
And this really boils down to show what it is: AI large language models as we currently implement them are such that they are probability based guessing machines, lacking consciousness, intent, will, true understanding or rationality.
English: Too high level (There and back again)
And now one might argue, "well you did not prompt the AI informing it to reply literally including grammar mistakes." But, this is missing the point! This is but only one case. This is only one person. What if John has other requirements, and what if Jan still yet more? How ever will it precisely behave, consistently, and certainly, in a way that can be counted on reliably, without ambiguity, if it is only to interface with me or John or Jan using mere English? Do not humans even misunderstand and have communication break-downs among one another? Yes, of course, but surely this is not the most effective way to command computers? And surely this is a technology that would be unwise to send in to space, or to connect to the nuclear red button!
Well, okay then. Perhaps we need to go from English back towards a real computer programming language, which then we can feed to the AI such that it understands precisely what we intend to build. But, now this begs the question, are we not going back again towards python, and away from the revolutionary guessing machine, such that, the more precision our projects require, the lower level our programming language needs to get to? And so we no longer now need the LLM.
The LLM it turned out, is insufficient in itself in understanding the complexity of a human as projects gain enough complexity that description in English alone becomes "open to interpretation." It is the generally reported feedback of most advanced computer programmers, that the more complex the project became, the harder it was for the human to describe his inspiration of the project to the AI in a way that the AI could understand; meanwhile, the AI seems to give an illusion of understanding us, while consistently delivering results that did not match our initial inspiration. It seems, there is a communication break-down.
"Open to interpretation" (Present the following J.R.R. Tolkien description to 5 different painters)
In a hole in the ground there lived a hobbit. Not a nasty, dirty, wet hole, filled with the ends of worms and an oozy smell, nor yet a dry, bare, sandy hole with nothing in it to sit down on or to eat: it was a hobbit-hole, and that means comfort"
The English is such that we all know what it means, but we imagine it differently as humans. The painters, undoubtedly, each would apply their own style, color accents and more each with their own take of the scene.
And this is all fine, so far, and I am sure we would have 5 very nice paintings, but none of this is how we intend to program a computer. English and other native tongues are just simply not built to command computers accurately by themselves. They are the evolutionary language of anthropology, and perhaps the inspiration to painters, but they are not the driver of computer science.
Of cars and horses
The problem now is, people seem to think we can throw real programming languages away, and that by adopting new LLM methodologies the naive computer user thinks they may surpass the traditional computer programmer. Let's consider the insanity of this only briefly,
AI users vibe coding in English are going to get far ahead of those who don't. It's like the car vs horse. AI just made 10,000 people expendible in my company. If you aren't AI native, you're next!
Some shill on X, probably.
Now when I hear this, I am hearing a subtle rejection of K&R, The C Programming Language, of Mccarthy's Lisp, or of Knuth's The Art of Programming and a whole host of other things. In favor of what? Ambiguous English dictation.
And the audacity is, that these things are said all the while standing on the shoulders of Kernels and Operating Systems made by humans, they generate code that only compiles in toolchains and compilers made by humans, in code that is only interpreted by interpreters made by humans. The generated code is derived from training data written by humans! The presumptious LLM user now intends to remove himself from the procreational energy source, cutting himself off from his own rationality: the soul of the art of programming itself being now lost. Cars vs. Horses? No. More like a step child yelling proudly "you're not my real dad, I can do it myself!" ... Well good luck bootstrapping your machine with a @#$!ing llama file, then...
We need to slow down and show some respect to our elders. Computer programming languages exist for a reason and that is because our forefathers knew they needed to create a language for humans to precisely and properly interface with computers. The reversion back to non programming languages such as English is archaic, and will lead to a new dark age of computer programming history.
Case Study: LSP (Language Server Protocol) and auto-completion
A new programmer sets out to code. He learns of auto-completion, he sees an advanced coder on youtube with a fancy editor that offers to complete what it statistically thinks is probably the most likely thing to complete. Various methods of inserting code snippets, boiler plate, function definitions, references and so forth, the person only need type partial code, hit TAB and poof, the wizard is typing code, oh so fast! And we had this prediction technology long before LLMs, and we have such that they are tied to our interpreters, compilers etc. in such a way that the predictions are typically pretty decent and helpful for the coder. The coder presses less keys, while still maintaining precision and completing to the screen only exactly the code he wishes to be there, refined precision: both speed and accuracy.
It would have been thought, and it has been thought by many, "OH MAN, this is going to make me a 10x developer! I'm now a super chad with my fancy auto complete." Only to realize later, when super chad begins to write his program, that it still takes him all day, that he is a slightly faster typer, but when he is programming, he is usually not typing at all! He, now being self aware, realizes that he spends most of his time planning, thinking, analyzing, and troubleshooting - alas, he often finds himself setting out to code before he fully knows what his code should even look like! - and he does all of this 10x more than he does typing in any new code at all! And so what he thought would be 1000% gains are perhaps only 10% gains.
This is because the bottle-neck, all along, was not typing speed, but was interface to the CPU. If only the CPU could understand the program that I am trying to translate to it from my brain, in C or in Python! But then I would have to use a real programming language, not English.
And that there, is the problem
How do I get the e.g. Python code out of my brain and on to the hard drive of this computer, in the most efficient way humanly possible?
While the guessing machine that is LLM can sometimes be of use for projects that may not require precision, for projects that are simple to describe and common such as "boiler plate", it is also a liability by its very nature, and cannot be counted upon for reasons already discussed in this article. Like the naive coder who hoped his auto complete would give him 1000% gains, we find in a coding project of any substantial depth the usefulness of the tool diminishes - as clarity decreases, while ambiguity increases, precision is lost. And this is because, LLMs do not solve the real problem: the human computer interface.
Brain implants and the cyborg dystopia
Perhaps, as a next step, we will begin to research how to grant LLMs access to read our brains, as translating agents between CPUs and the human mind? It seems to me, that this is the logical next step, to be paired with brain cybernetics that perhaps could increase our human cognitive context size, if we intend to seriously use LLM technology for advanced computer programming.
But something tells me, that when humans go down this dystopian path, they will end up serving the AIs as their master, and not vice-versa, all the while thinking they are in the drivers seat.
The whole idea, is cursed.
Back to the future
In summary, Unlike a proper programming language, LLMs being statistics-based guessing-achines, interfaced via abiguous English that is "open to interpretation" are not guaranteed to give the same outputs when given the same inputs. Thus they are prone to error and not guaranteed to improve developer productivity, and by whatever margin they do improve productivity, it is unlikely to be a 10x, 1000% gain, especially when the fact that it is a borrow-now, pay-later approach is considered. Unless perhaps the developer was only ever doing trivial things that did not require precision to begin with. This is the developer who is most impressed with LLMs. This is also the developer who is going to do the most damage (to himself, and others) while using LLMs.
If the broader programming culture adopts and normalizes generative AI while abandoning ownership of knowledge, then the creative soul is removed from the process. And it is the soul that is tied to the human's rational faculties per Aquinas. The problem then is not a future with sentient LLMs, but instead is a future where the human has become an NPC, no longer knowing the difference.