Why This Debate Suddenly Feels Everywhere

Lately, the tech community feels unusually tense. Not because of layoffs, not because of frameworks, but because of a phrase that sounds harmless on the surface: vibe coding.

The term was casually popularized by Andrej Karpathy, describing a way of coding where you lean into intuition, prompt AI heavily, let the system generate most of the scaffolding, and focus more on direction than execution details. You guide the flow. You don’t obsess over every keystroke.

Predictably, the backlash came fast.

People started warning that vibe coding is dangerous. That it encourages shallow thinking. That people without proper computer science backgrounds are suddenly “building software” without understanding what’s really happening underneath. And almost every warning ends with the same sentence:

“You still need fundamentals.”

The Problem With “Fundamentals” as a Blanket Statement

At first glance, that sounds reasonable. Sensible, even. But the more I listened, the more something felt off. Not because the statement is wrong, but because it’s incomplete.

What fundamentals, exactly?

This is where the conversation usually collapses into noise. Everyone agrees fundamentals matter, but no one ever defines the boundary. Are we talking about understanding how a CPU executes instructions? Knowing binary and assembly? Understanding memory allocation and pointers? Compiler internals? Operating system scheduling? Networking at the packet level?

All of those are fundamental, depending on how far back you zoom.

But here’s the uncomfortable truth: most working engineers today don’t operate anywhere near that level.

We Are Already Far From the Machine

We write code in high-level languages. That code gets translated by compilers or interpreters into intermediate representations, then into machine code, then into instructions the CPU can execute. There is binary involved, absolutely. But, most of us never see it, touch it, or think about it.

And yet, software ships.

Cashier systems run. Inventory apps work. Library management systems exist. Businesses operate just fine without their developers knowing how an instruction pipeline works or how memory is laid out byte by byte.

So when someone says, “You must know fundamentals”, what they often mean is not all fundamentals, but their fundamentals. The ones they learned early. The ones that gave them identity. The ones that hurt.

That’s not a compass. That’s nostalgia.

Abstraction Didn’t Start With AI

What makes this debate interesting is that vibe coding didn’t invent abstraction. It simply made abstraction visible enough that people got uncomfortable.

Programming has always been a story of rising abstraction. Early programmers needed to understand the machine because there was nothing else. As tools evolved, we moved up: from machine code to assembly, from assembly to higher-level languages, from languages to frameworks. Each jump removed a layer of concern while expanding what one person could build.

AI is not breaking that pattern. It’s continuing it.

The difference now is psychological. With AI, the abstraction leap feels sudden, and it threatens a long-held belief: that suffering through technical depth is the only valid way to earn the right to build software.

What Engineering Was Always About

But here’s the thing we rarely say out loud: the goal of an engineer was never to understand everything. The goal was always to solve problems under constraints.

Constraints change. Tools change. Abstractions rise.

And as abstractions rise, the definition of “fundamental” shifts with them.

In the past, knowing a programming language was fundamental. Later, understanding frameworks became essential. Today, understanding system behavior, edge cases, failure modes, and logic flows matters more than memorizing syntax. In an AI-assisted world, being able to reason, validate, and take responsibility for outcomes becomes more important than knowing how many bytes a pointer consumes.

A Pattern Bigger Than Software

That doesn’t mean fundamentals disappear. It means their center of gravity moves.

From a human perspective, this isn’t even unique to software. Anthropologically, humans have always progressed by offloading complexity. Writing replaced memory. Tools replaced raw strength. Institutions replaced constant negotiation. Each time, people feared decline. Each time, capacity expanded instead.

AI is just another layer in that long story.

The Question Worth Asking

So no, I’m not here to cheer for vibe coding, and I’m not here to defend it blindly. Vibe coding without understanding consequences is reckless. But shouting “fundamentals!” without defining them is equally lazy.

The real question isn’t whether fundamentals matter. The real question is: which fundamentals are required to solve this problem, at this scale, in this context—today?

That answer will keep changing. It always has. And if someone’s definition of fundamentals never evolves, then the problem isn’t vibe coding.

The problem is that they stopped adapting.