I'm Jack, creator of LearnGit.io, and The Modern Coder is my online moniker. Going forward, your newsletters will come from The Modern Coder. Same content, same person — just one brand. If you only want LearnGit.io product updates (new courses, platform changes etc), switch to product-only emails by clicking here.

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. 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 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.

This doesn't feel like an existential threat. It feels more like the same pattern that has defined computational advancement since the beginning. The question is how long the current "leaky" phase lasts before AI coding matures enough that the abstraction holds on its own.

•

If you have thoughts or relevant resources to share, reply and let me know. My knowledge of this space is still admittedly shallow, but I'm finding it helpful to hear what others think.

Cheers,