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

The term "AI" covers a large surface area — language models, chatbots, agentic coding, AGI etc — so understanding how it will change our industry seems like a laughably unanswerable question, yet it's not.

Every few decades, computing adds a new abstraction layer that makes the previous one less critical to understand. Think about the progression thus far:

• Raw silicon gave way to binary.

• Binary gave way to assembly.

• Assembly gave way to BASIC.

• BASIC gave way to managed languages like Java.

Each transition followed a similar pattern: the new layer eventually made the lower one something most practitioners no longer needed to think about.

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

When BASIC arrived, programmers no longer needed to worry about which CPU registers were being populated. When Java arrived, memory management (ahem, C) thankfully became a conceptual exercise instead of a day-to-day frustration. But in both cases, there was an early period where the lower level still leaked through — where you still needed to understand what was happening underneath to use the new layer effectively.

That's exactly where we are with AI coding right now. The abstraction isn't mature yet. LLMs are our new compiler, and agentic coding, context management, prompt engineering, etc. are our new programming language. The lower level — actual programming knowledge — still constantly leaks through. In the professional software engineering space, you still need to understand code to use these AI tools to their full potential, to catch their mistakes, and to guide them toward correct solutions.

But the trajectory is 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.

Nobody in their right mind would write modern software in assembly, so we could theorize that in 70 years, nobody in their right mind would write code manually.

This isn't a threat. It's the same pattern that has defined computing since the beginning. The only question is how long the current "leaky" phase lasts before AI coding matures enough that the abstraction holds on its own.