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 so often, a new abstraction layer comes along that makes the previous one less critical to understand. Something like this:

• 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 programmers 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 — in other words, you still needed to thoroughly understand what was happening underneath to use the new layer effectively.

That’s feels 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, language nuances, 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: 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.