The Metaphysics of Vibe Coding (or the Absence of It)
Last updated: 28 July 2026.
While discussing the nature of agentic coding with a friend who is just starting out with the practice, it occurred to me that the current debate around its usage ("disposable code", "phoenix architecture" etc.) has a philosophical dimension hidden in plain sight.
It's the old dichotomy between metaphysics - the notion that there is a deeper layer beyond matter (an "essence", a division between "body" and "soul") - vs phenomenology or materialism - the opposing idea that the world is populated by all we can sense, and nothing more (Philosophy buffs please excuse my crudeness here. The point I'm trying to make will become clear in a minute).
Why is that interesting? If you've been following the public debate about artificial intelligence in general and software engineering in particular, you get the sense that contenders fall into one two camps, generally:
Agentic coding evangelists preaching the advent of disposable code, emphasizing that "the code was never the problem, (understanding and designing) the system was."
This boils down to Plato's cave allegory cast into code: We can never see what the actual ideas are, nor does it matter. All we see are shadows on the wall, i.e. the effects they have on or world. This is an almost Cartesian division of mind over matter. "Cogito ergo sum", I think therefore I am, I shape the system with my thoughts and let the dirty work be done by the obedient robots.
Interestingly this argument is most often expressed by people who have gained lots of experience over time coding by hand.
The other camp is composed of people praising the value of hand crafted code and how it enforces the understanding of how your program works from within, what changes you can make to it, and the tree of decisions that went with it.
This notion is well footed, too: Human cognition, you could argue, evolved from the use of our hands, how we used them first to create primitive, then ever more sophisticated tools. You could reason that humans always think externally, in artifacts, to some degree. To illustrate this point, take Tetris: Theoretically we could envision the correct move with a block at certain time first, then perform it. But we never do that. We rotate, move left, right, until we find the correct spot and drop it.
You could counter that with the idea that we should finally move beyond this cognitive barrier, and that AI takes the role of midwife in this process.
The most prominent philosophical proponents to refer to would probably be Husserl, Heidegger, Derrida.
Where do I stand in that discussion? To be honest, after I became aware of this dimension, I spent way too much time musing on my stance here. Until it dawned on me that I don't have to choose sides.
In philosophy, this is a fierce debate. The nature of the subject dictates that only one of both worldviews can be true.
When framing the agentic revolution, I'd argue it's paramount that you view it through both lenses. And here's the upshot:
The real skill lies in knowing when to choose which.
Unconsciously, I feel uncomfortable when I let Claude build the centerpieces, the fulcrums of the systems I code. That's because from years of practice, I've become used to rotating the Tetris blocks instead of just imagining them. This is certainly the legacy of my human ancestors looking at the crude hammer they've built and deciding which side to use for punching in a nail.
But my intuition certainly is telltale here, and after half a year of heavy agentic coding, I'm open to giving in to it a bit more again. I want do be an active part of the decisions that go into the design, and not just cheer from the sidelines.
Sometimes though, I have to build something that's not central to the business logic. Quite literally, I'm looking at the borders to other systems, i.e. outward facing APIs, incoming webhooks, MCP servers (!) etc. Often that can also be something like a background job, a test, or integration with other services (API clients, OAuth, etc.). Claude is actually great at those and I found myself even enjoying reviewing the tests it writes and poking at the holes.
So if there's one key takeaway from these ramblings, it's this: Build the centerpieces yourself, let the agents build the seams.
Do you agree or disagree? I'd love to hear from you.
P.S. Interestingly, the main insights came from agentic coding my own musical instruments/systems. I'd code the core behavior (a delay, a granular looper, an FFT effect) myself and let Claude handle talking to other systems or the outer world (MIDI integration, sequencers, ...). Once again, it all boils down to the same principles.
Want pieces like this delivered to your inbox? Subscribe here: