Standing on the Shoulders of Abstraction

September 27, 2026

Each generation offloads previous “foundational knowledge” to abstraction, and the world reaps its benefits. I don’t have to learn how transistors work, or how they form logic gates, or how those logic gates become the programming languages in order to build a website - despite being several layers above the technology that powers it. If I had to learn how transistors work - if humanity had to learn each piece of foundational knowledge without abstraction - I wouldn’t have the time, bandwidth, nor cognitive load to build anything considered meaningful. Without abstraction, the ability to accept foundational knowledge as fact and move on, society stagnates and effectively stops. But should all foundational knowledge be handed off to abstraction?

When I programmed this website, I used skills such as structuring a page so it is easy for the user, designing visually appealing pages, and translating these skills into actual code. Despite my website depending on transistors, the actual knowledge of them was irrelevant to building my website. The ability to program and the ability to understand transistors don’t touch. If my website doesn’t behave like I expect, I know it is because of a bug in the code, not a transistor - the failure stays within my boundaries and my knowledge. I believe this is a true test of abstraction safety: not whether the knowledge is foundational, because it all is - but whether the skill practiced at the layer above depends on the knowledge of the layer below. If those two layers merely rest on each other, and do not touch, then it is safe to abstract.

An example of unsafe abstraction, by this test, is math. In school we learn simple arithmetic, then algebra, geometry, and calculus. Derivatives aren’t just extremely difficult to compute without algebra - it’s unintelligible without proper understanding of all the layers below. To even understand what a derivative is, you need to understand functions, slope, and ratios. Calculus doesn’t rest on algebra the way code rests on transistors. Calculus intersects, is built on and out of algebra. What makes this even more interesting is this same stack - algebra to calculus to multivariable calculus to linear algebra - lies underneath the modern AI that is testing how we think about learning altogether.

AI erodes the distinction between layers that touch and layers that merely rest on each other. Before modern-AI, cases considered “unsafe abstraction” were never optional to skip in the first place. You simply can’t get to calculus without algebra. But AI avoids this sequence altogether - it gives you the direct output without needing to travel through the layers underneath it; a derivative, an essay, a program, a video, a script can all be generated with AI, and I don’t need to understand any of the knowledge underneath it regardless of which kind of layer it’s skipping. Now, the abstraction test isn’t self-enforced as before. Abstraction is no longer required by the skill itself. It is a deliberate decision by the user.

While building this website, I used Copilot (a coding-assistant AI) to edit elements so that they all followed a coherent theme. I understood exactly what it changed - I know that it edited the styles.css file, that it made certain edits background color, fonts, and font size. If it made an edit I disliked, I have the ability to change it. Maybe I would still use AI to fix it, but ultimately, I could do it myself. Today, the skill of designing something that looks coherent does not rely on fully memorizing CSS syntax. Here, the output layer rests on the one below it, but they do not touch. To build a different website, I had Codex (another coding AI) build a database schema in Postgres. This example is different. I don’t fully understand Postgres, and I can’t even fully grasp the SQLAlchemy used to access the Postgres data. The schema works, but I cannot say with absolute certainty why or how. I cannot say that it was compiled in the most efficient manner, or that there were no errors, because doing so requires knowledge and skill in all the layers underneath, the exact layers I skipped. While the tool I used remained the same - AI - whether the skill I was borrowing rested on the layers below or touched them changed completely.

Ultimately, the importance of this idea and rule I have created for abstraction relies on the future. If AI still needs a human to verify its work - to check for hallucinations and misalignment - then the test of “rest vs. touching” would still be relevant. If the errors in frontier models become negligible enough, and AI stops needing human input, verification, or reinforcement - even scarier stops needing human curated data - then the whole test collapses. It won’t matter whether a skill rests or touches the layers beneath it because understanding the skill itself will be unnecessary, the output itself becomes the new foundation - one which nobody needs to understand the layers underneath. I don’t know which outcome will occur, and nobody does for certain, which makes it so hard to format a clean argument for either side.

When I used Codex to build the Postgres database schema, I felt a little embarrassed to admit I didn’t understand it. This reaction could be significant, a sign that we are headed for a world that still depends on foundational knowledge. The effects of our current world could also be lingering, old instincts from a world where understanding your work was actually important. For now I hope to notice the layers I’m standing on rather than ignore their existence.