Abstraction Is Forgetting on Purpose

The Layers We Stand On

Every abstraction is an act of forgetting. Binary forgets voltage. Assembly forgets binary. C forgets assembly. Python forgets C. And now, LLMs forget the code entirely. You describe what you want in English and something executable comes back. Each layer discards detail to gain leverage. That's the deal. And when the deal is made consciously, when you understand what you're giving up, it's one of the most powerful moves in engineering. The problem starts when the forgetting is inherited rather than chosen.

Chosen vs. Inherited Forgetting

A senior engineer who writes Python instead of C is making a deliberate tradeoff. They know what memory management is. They know what a pointer does. They've chosen to forget those details for this task because the abstraction serves them. A junior developer who has never written anything below Python isn't making that tradeoff. They're standing on a layer they can't see through. The abstraction isn't a tool; it's the floor, and they don't know there's a basement. When the abstraction holds, both developers produce equivalent output. When it leaks (and it always eventually leaks) only one of them can debug what's happening underneath. I taught myself Linux to write better documentation at Logpoint. Not because anyone asked me to; because I was covering SIEM and SOAR products and couldn't explain the architecture I didn't understand. That decision to go one layer deeper than the role required has defined how I approach every domain since. The forgetting was chosen. That made all the difference.

The AI Layer

LLMs add a new floor on top of the stack. You describe intent, and code appears. You describe a bug, and a fix materializes. The abstraction is so smooth that it's tempting to treat it as the ground floor. If you've written code by hand, struggled with type systems, debugged race conditions, then using an LLM to generate code is chosen forgetting. You know what's being abstracted. You can read the output critically. If you've never done those things, the LLM output is a black box that happens to compile. You're not abstracting. You're trusting.

Trust and abstraction look identical until something breaks.

Why This Matters for System Design

The same principle applies when building AI systems, not just using them. At EkLine, we spent weeks deciding what to encode into the system's scaffolding versus what to let the model infer. Every decision was a forgetting decision: what does the system not need to know explicitly? What can it figure out from context? The answers that worked were always the ones where we understood the forgotten layer deeply enough to know when the model would get it wrong. We weren't hiding complexity. We were compressing it. And compression only works when you know what the original looked like.

The Rule

Abstraction is powerful when it compresses understanding you already have. It's dangerous when it hides understanding you never built. Every layer in the stack is an invitation to forget. The only question is whether you're choosing to forget or whether you never knew in the first place.

The gap between those two is invisible in normal operation and catastrophic in failure.