We’re Still Teaching AI to Build Faster Horses
Scroll through any developer feed today and you’ll see the same debates repeating themselves:
Will AI replace software engineers? Is AI-generated code safe or maintainable? Is “vibe coding” a bad practice?
All of these discussions share a hidden assumption—that the way we build software today will stay fundamentally the same, just with AI assisting along the way.
I think that assumption is wrong.
A quick look back at abstraction
I started my software journey as an embedded systems engineer, writing code for microcontrollers. Before Embedded C—already considered a high-level language—I worked with assembly. In both cases, the end result was identical: hex code written into EEPROM, executing predefined logic on hardware.
Later, as a side hobby, I worked with ActionScript (RIP Flash), which eventually helped me move into the JavaScript ecosystem and shift my career toward web development. That transition gave me a front-row seat to how quickly “high-level” changes over time.
During the rise of HTML5 and Web 2.0, JavaScript development evolved rapidly. jQuery simplified DOM manipulation. Frameworks like Angular and Meteor raised the abstraction even further. Node.js brought JavaScript to the server, and bundlers like Webpack, Parcel, and later Vite automated more and more of the complexity.
Yet through all of these changes, one thing remained constant: the output was still plain JavaScript, HTML, and CSS. We didn’t remove layers—we kept stacking new ones on top of the old ones.
AI as a mechanical horse
Imagine a horse pulling a cart. When humans first invent an engine, the most natural idea isn’t to build a car—it’s to replace the biological horse with a mechanical one. Same cart, same mental model, just powered differently. Only later does the real leap happen.
This is exactly how we’re using AI today.
Most AI tools focus on writing React components, generating boilerplate, or refactoring existing code. In other words, AI is acting as a mechanical horse—doing the same job in the same system, just faster.
That’s useful, but it’s not the real disruption.
The leap we’re not talking about
Throughout the history of software, we’ve relied on abstraction layers to bridge the gap between human intent and machine execution. Readable, maintainable code exists primarily for humans—not for machines.
So the real question isn’t whether AI can write better React code.
The real question is: what happens when AI no longer needs our abstractions at all?
Instead of asking AI to write React, we could ask it to generate the final executable logic directly—the lowest-level representation that satisfies our intent. Frameworks, languages, and even code structure become implementation details rather than primary artifacts.
When that happens, yesterday’s “high-level” tools will become today’s low-level plumbing.
What this means for developers
This shift won’t eliminate software engineers, but it will change what software engineering looks like. The focus moves away from writing code line by line and toward defining goals, constraints, behavior, and outcomes.
In that world, programming becomes less about syntax and more about intent.
Most AI discussions today are still about faster horses.
But the era of evolving into cars is not far.
Top comments (0)