AI as an abstraction layer

Over the past few months, I’ve been digesting what AI and these new LLM-powered coding tools, like Claude Code, might mean for the future of software engineering.

This probably isn’t an original thought, but here’s my theory:

Every few decades, computing adds a new abstraction layer that makes the previous one less critical to understand. The progression thus far can be read as something like htis:

• Raw silicon gave way to binary.
• Binary gave way to assembly.
• Assembly gave way to BASIC.
• BASIC gave way to C/C++.
• C/C++ gave way to managed languages like Java.

Ok yes, I missed a few abstraction layers, but you get the idea. Each transition followed a similar pattern: the new layer eventually made the lower one something most practitioners no longer needed to deeply think about.

One could imagine AI coding being the next layer in that stack.

When BASIC arrived, programmers no longer needed to worry about how CPU registers were being populated. When Java arrived, memory management for the most part became conceptual exercise rather than a day-to-day frustration (Anyone want to go back to pointer hell in C/C++?). However, in both cases, there was an early period where the lower level still leaked through — where you still needed to thoroughly understand what was happening underneath to use the new layer effectively.

That’s feels exactly like where we are with AI coding right now. The abstraction isn’t mature yet. Are LLMs our new “compiler”? Is agentic coding, context management, prompt engineering, etc. our new “programming language”?

Either way, at present, the lower level — actual knowledge of programming languages — still constantly leaks through. It’s critical for professional software engineers to understand design patterns, programming languages, system design etc. to use AI tools to their full potential. To catch their mistakes, and to guide them toward correct solutions.

But the trajectory feels predictable: we’ve seen it play out repeatedly over 70 years of computing history. As these tools become more mature and comprehensive, understanding what came before becomes less critical. What becomes more important is understanding what’s coming next — how to work with the new layer, not the old one.

Through this lens, AI doesn’t necessarily have to feel like an existential threat. Maybe it’s same pattern that has defined computational advancements since the beginning. The question is how long the current “leaky” phase lasts before AI coding matures enough that the abstraction layer holds on its own.