create-react-app
replaced project scaffolding. And now AI agents are removing the need to write code ourselves.The uncomfortable question isn't whether this trend is real — it obviously is. The question is what happens when the abstraction envelope swallows the role we built our careers around.
The Rails Parallel #
I remember the exact moment Rails clicked for me. Coming from a world of XML-configured application servers and hand-written deployment scripts, seeing a framework that just knew the right defaults felt like cheating. But it wasn't cheating — it was compression. Rails bundled decades of accumulated best practices into convention, so I could skip the decisions I didn't care about and focus on the ones that mattered.
That compression didn't eliminate the need to understand what was happening underneath. When a Rails app broke at 2 AM, I still needed to trace through middleware, understand ActiveRecord queries, and read SQL logs. But the abstraction meant I didn't carry all that knowledge for every single task. I only reached for the deep stuff when necessary.
The Agent Shift #
What makes AI coding agents different from every abstraction that came before is the target of the compression. Previous tools packaged setup and repetition. They handled boilerplate, scaffolding, and rote implementation patterns. The actual act of thinking through a solution — the design, the trade-offs, the architecture — still belonged to the engineer.
AI agents are now reaching into that territory too. Give one a set of GitHub issues, and it opens branches, writes tests, iterates on failures, and submits PRs. The loop of "think → implement → verify" is partially happening inside a model rather than inside my head.
This feels qualitatively different from yo webapp
or Heroku's git push
deploy. Those tools removed friction. Agents remove agency — or at least they start to look like they do.
What We Actually Lose and Keep #
Here's what I think is worth sitting with:
We won't lose the need for software design skills. Decidingwhatto build andwhystill requires human judgment about context, ethics, and business reality.We will lose the gatekeeping that "knowing how to code" provided. Just as Rails let non-Java developers build web apps, agents will let non-engineers describe software in plain language.Our value will shift toward the edges. Reviewing agent output, defining constraints, handling ambiguous requirements, and debugging failures that happen at the boundary between what the agent understood and what we actually needed.
The scary part isn't that agents are bad at coding. It's that they're good enough to make the question "do we even need to code?" feel legitimate for the first time in decades.
The Real Abstraction We're Wrestling With #
Every layer of abstraction in computing history has eventually become invisible infrastructure — things we no longer think about because they just work. Operating systems, memory management, networking stacks. We forgot they existed because they became invisible.
The real question isn't whether AI will abstract away coding. It's whether we'll let it abstract away understanding. Because the moment we stop caring how the code works, we lose the ability to reason about when it's wrong — and software that can't be reasoned about is software waiting to fail in production at the worst possible moment.
The abstraction is coming. The only choice we have is whether we stay close enough to the machine to still understand what it's doing when things go sideways.
Next Understanding Over Origin →