Working in the Fog of Abstraction

A few weeks ago, I was staring at a layout that looked fine. It was clean, functional, and readable. But I hadn’t written it. I had generated it using V0.dev.

Technically, everything was there. The spacing was correct, the structure was solid, and the code was acceptable. But something about it felt wrong. I could not explain why. It just did not feel like mine.

That was the moment it clicked for me. I was working with something I did not understand well enough to shape with instinct. I had not written it. I had not made the decisions behind it. I was editing someone else’s draft, and in this case, the “someone else” was an AI.

It was not a catastrophic moment, but it lingered. Not because the tool was flawed, but because it revealed a quieter discomfort. It made me wonder how often we are building on layers we have stopped noticing.

Abstraction Is Everywhere, and That Is Not the Problem

Abstraction is not some advanced engineering trick. It is how we survive modern life.

• You set an alarm without understanding how your phone schedules background tasks.
• You use maps without thinking about satellites or networks.
• You hit “pay” and trust that someone has made sure the transaction works.

We live on top of hidden systems. That is what makes complex software and modern conveniences even possible. Abstraction lets us focus on intent. It protects our attention and hides details until they matter. When done well, it provides leverage, clarity, and speed.

But abstraction is also a gamble. The moment you stop noticing what is underneath, you lose your ability to question it. You start to rely on things you could not fix if they broke. You stop shaping the work intentionally. Slowly, you stop feeling responsible for what you are building at all.

In Software, Abstraction Shapes Everything

I move between design and code every day. I work inside abstraction constantly.

• Design systems hide typographic decisions inside tokens.
• React hides DOM logic behind components.
• API calls hide infrastructure.
• Developer tools hide deployment pipelines.

None of this is a critique. It is how work gets done at scale. But every layer of abstraction carries assumptions. Those assumptions create defaults and trade-offs. If we are not aware of those trade-offs, we end up solving problems we do not fully understand with tools we cannot explain.

AI Tools Are Changing Where the Work Begins

Generative tools like V0.dev, Copilot, and Cursor can give you layouts, components, or even logic in seconds. They are fast, often faster than expected.

This is where the shift begins. The first draft is no longer shaped by you. It is generated by the tool, based on patterns it has seen, not based on your intent or thinking.

I have noticed that these tools do not remove the work. They simply relocate it.

• You go from writing to editing.
• You shift from implementation to judgment.
• You spend less time deciding how to build something and more time deciding whether the output is even right.

This requires a different kind of skill altogether.

Why We Resist Abstraction, Especially Now

I have seen engineers push back on AI tools and code generation. Often the pushback sounds like, “If you don’t understand the code, you shouldn’t be writing it.”

But beneath the surface, the resistance feels more personal.

There is a sense of loss when the thing you were once proud of becomes a black box. The craftsmanship you spent years developing starts to feel irrelevant. Suddenly, autocomplete or AI tools replace the process you cared about.

I understand that frustration. When I see a fully generated layout that technically works, it rarely feels satisfying. It skipped the part where I shaped it. It skipped the part where I cared about the details.

But maybe that is the adjustment we need to make. It is not just about accepting code generation. It is about understanding the new responsibility that comes with it.

• The responsibility to notice.
• The responsibility to override decisions when needed.
• The responsibility to step in when something feels off.

The tools are not asking us to stop thinking. They are asking us to decide when to think more critically.

The New Skill Is Not Total Control, It Is Navigation

Abstraction is not going away. If anything, it is increasing. AI tools have accelerated this, but they did not start the trend.

The skill that matters now is not mastery of every layer of a system. It is the ability to choose which layer to focus on. It is knowing when to zoom in, when to trust the tool, and when to question the results.

This is not purely a technical skill. It is a perceptual one. It is about staying aware of the layers you have stopped seeing and making the choice to look again. That is the difference between building with abstraction and building in a fog.

Questions I Ask Myself More Often Now

• What layer am I operating in, and does it matter for the decision I am making?
• What is being abstracted away from me, and what might it cost me not to see it?
• Is this abstraction helping me think clearly, or dulling my instincts?
• Do I understand this well enough to shape it intentionally, or am I rearranging someone else’s decisions?
• If this breaks, do I know where to start looking? Or will I be stuck at the surface?
• If someone inherits this work, will they feel clarity or confusion?

Not every layer requires inspection, but some of them do. The skill is not memorizing how every system works. It is maintaining the awareness to know when you need to understand more.

Abstraction Is Not the Enemy. Unconscious Abstraction Is.

We use abstraction to work faster, scale systems, and simplify complexity. That is not the problem. The problem begins when we stop noticing what we have skipped. We lose not only technical detail, but also judgment. We lose the ability to ask better questions.

We should not fear AI tools, low-code platforms, or systems that move faster than we can. But we do need to stay responsible for what those tools hide.

Because when things go wrong, it is rarely the tool’s fault. It is our fault for not knowing where the edge of the abstraction was.

Care Still Lives in the Layers

We can move fast. We can start with prompts. We can generate layouts, scaffold components, and delegate parts of the build process. We should use these capabilities.

But the fundamental truths of good work have not changed:

• Contextual taste still matters.
• Intuition still matters.
• Judgment still matters.

Abstraction hides complexity, but it does not eliminate the need to understand the system beneath it, at least at the moments when it counts.

Especially when something feels off. Especially when we care about the quality of what we create. If you have stopped noticing the layer you are building on, it might be time to look again.

Not to slow yourself down unnecessarily. Not out of fear. But because noticing is still part of the work. And care still lives in the noticing.