LLMs: The Next Rung on the Ladder of Abstraction

TL;DR: LLMs continue the history of software abstraction—from the perspective of intent replacing implementation, they make natural language a new interface, enhancing human agency, but they will not end programming; rather, they are a new step on the ladder. ## Introduction: Starting with a 1975 Prophecy Imagine walking into a software company in 1975 and telling a room full of assembly programmers that in 50 years, millions of people who have never studied computer science would be able to build software just by describing what they want in English. They probably wouldn't believe you. It's not that computers couldn't do it, but because they couldn't imagine that this ladder could go up another rung. Today, we are witnessing that rung emerging in reality. The history of software is actually not the history of programming languages, but the history of abstraction. Every time we climb a new level of abstraction, it greatly expands who can create software and what they can create. Large language models are not breaking this pattern; they are continuing it. ## What Exactly is Abstraction? People often say abstraction is hiding complexity. That's correct, but there's a better definition: **Abstraction is the process of replacing implementation with intent**. Think about driving a car. When you press the accelerator, you don't think about spark plugs, fuel injectors, crankshafts, or combustion chemistry. You're just expressing an intent: accelerate. Everything underneath converts that intent into thousands of mechanical operations. The complexity doesn't disappear; it's just hidden behind the interface. Software works exactly the same way. When a programmer calls the `sort` function, they are not comparing memory addresses instruction by instruction. Someone else has already solved that problem. They just need to say: 'Sort this list.' That's what abstraction does—it lets humans think less about 'how it happens' and more about 'what they want.' ## The History of Software Abstraction: Each Level Stands on the Shoulders of the Previous Once you look at software from this perspective, the entire history of computing becomes clear: - **Machine code**: Programmers directly told the processor what electrical operations to execute. - **Assembly language**: Replaced numeric instructions with symbolic instructions. - **Compiled languages (Fortran, C)**: One line of source code becomes dozens or even hundreds of machine instructions. - **Operating systems**: Abstracted hardware. - **Libraries**: Abstracted common algorithms. - **Frameworks**: Abstracted application architecture. - **Python**: Abstracted a lot of boilerplate code that early programmers had to write manually. Each step follows the same pattern: computers become more complex, while programmers' work becomes simpler. Or more accurately, programmers can spend more time thinking about real problems. ## Python Is Not the End; LLMs Reverse the Relationship For a long time, Python felt like the ultimate boss of abstraction. Its syntax is so readable that people joke it's basically English. But it's not. Python is still a programming language. Every colon must be there, every indentation must be correct, every keyword must be precise. Computers still require humans to translate their intent into its language. Large language models reverse this relationship. Now we describe intent in our language, and the models translate it into code. This is a completely different level of abstraction. Instead of writing 'create this class, import these libraries, instantiate these objects,' we just say 'build me an application that can do X,' and the machine handles the implementation itself. ## Agency: The Key at Every Level of the Abstraction Ladder This brings us to a concept I consider most important: **agency**. Every level on the abstraction ladder enhances human agency. Machine code programmers had incredible control over the processor, but they could do relatively little in a day. Today's software engineers can build products that would have required hundreds of programmers 50 years ago. Programmers aren't necessarily smarter; they're standing on the abstractions accumulated by generations. That's why economic value tends to move upward. We still need chip designers, compiler engineers, and operating system developers. These jobs won't disappear. But most businesses don't create value by optimizing processor registers; they create value by solving customer problems. The more your tools can get close to the customer problem, the more leverage you have. LLM programming agents will push this boundary upward again. Developers no longer spend hours writing syntax; they spend more and more time defining goals, reviewing solutions, and making architectural decisions. Scarce resources are shifting: less syntax, more judgment. ## AI Is a 'Normal Technology,' Not Magic Some might be inclined to think this is unprecedented. I don't think so. Researchers Arvind Narayanan and Sayash Kapoor describe AI as a 'normal technology.' I think that's entirely correct. Electricity is a normal technology, the internet is a normal technology. Companies gradually reorganize around new capabilities. This is exactly what is happening with AI programming: models keep improving, companies progressively redesign workflows, engineers adapt, organizations change. This is not magic; it's technology diffusion. This means history might be a better reference than science fiction. ## The Future: From 'What to Build' to 'What Outcome Is Desired' This leads to the most interesting question: If natural language is today's abstraction, what is next? I think we won't stop at telling software what to build. Eventually, we will tell software what outcome we want. Not 'build a claims processing application,' but 'reduce claims processing time by 30% without increasing fraud and staying within budget.' The system will decide for itself whether software is the solution. Maybe it will change workflows, interview employees, automate paperwork. Maybe it will build software. Maybe it will do all four. We no longer specify software; we specify reality. That would be a completely different level of abstraction. The history of software has always been about widening the gap between what humans have to say and what computers can do. Machine code required us to think like processors, assembly made us think like programmers, high-level languages made us think like engineers, LLMs make us think like users. The next level of abstraction may make us think like managers or policy makers. ## Conclusion: The Ladder Keeps Extending Upward Lower levels won't disappear; they never have. There will always be people who need to understand the underlying workings. But the biggest opportunities will continue to move upward, to the highest level where human agency can be applied. That's why I don't think LLM programming agents will be the end of programming. They are just a new rung on the ladder we've been climbing for the past seventy years. And if history is any guide, there are more rungs above us. Source: https://youtu.be/ygN15LmaacE