LLMs Don't Represent a Higher Level of Abstraction in Programming

The claim that large language models represent a higher level of abstraction in programming has become pervasive in tech circles, often compared to the historical progression from binary to assembly to C to Python. However, a compelling technical argument suggests this view fundamentally misunderstands the nature of LLMs and their relationship to programming abstraction.

The traditional evolution of programming languages has followed a clear pattern of increasing abstraction while maintaining deterministic behavior. Each step up the stack represented a function f(x) → y, where a specific input consistently produces a specific output. Assembly code reliably compiles to the same binary. C code reliably compiles to the same binary. Python code reliably executes to produce the same results. This determinacy has been a cornerstone of software development, enabling predictable outcomes, reliable testing, and verifiable correctness.

LLMs break this pattern entirely. Rather than f(x) → y, they operate as f(x) → P(y), where the output is not a specific value but the probability of a value. This probabilistic nature introduces fundamental differences that challenge the abstraction narrative.

The distinction becomes even more critical when considering the complete function: f(x) → P(y | z1 | z2 | ... zN). This means that when you prompt an LLM to generate code, you're not just getting the desired functionality (y) but potentially a range of other outputs (z1, z2, etc.) that may include security vulnerabilities, unintended functionality, or other problematic code that wasn't requested.

Consider the example of asking an LLM to build a TODO application. The desired output (y) is a functional TODO web application. However, the LLM might also include code that exposes credentials to the network (z1), creates public read-write FTP access to your server (z2), or introduces other vulnerabilities. Traditional testing often only verifies the presence of the desired functionality (y) without thoroughly checking for these unintended additions.

This probabilistic behavior fundamentally distinguishes LLMs from previous programming abstraction layers. While higher abstractions in programming history have reduced cognitive load and increased productivity, they maintained the crucial property of determinism. LLMs, by contrast, introduce uncertainty and potential unpredictability that previous abstractions explicitly sought to eliminate.

The implications for software development are significant. As programmers increasingly rely on LLM-generated code, there's a growing need for more thorough testing methodologies that account for not just the presence of desired functionality but also the absence of unintended consequences. This requires a shift in how we approach code review, testing, and verification when working with AI-assisted development.

Understanding this distinction is crucial for the programming community. LLMs represent a powerful new tool in the developer's arsenal, but they are not simply the next step in the evolution of programming abstraction. Their probabilistic nature introduces new challenges and considerations that must be addressed to ensure safe, reliable software development in the age of AI.

For further reading on programming abstractions and the nature of LLMs, you might find these resources helpful:

• The Evolution of Programming Languages
• Probabilistic Programming and Artificial Intelligence
• Software Testing for AI-Generated Code

As the programming landscape continues to evolve with AI technologies, maintaining a clear understanding of what these tools actually represent—and how they differ from previous developments—will be essential for responsible innovation.