You’ve seen the demos. A developer types a vague prompt into an LLM, and in seconds, a fully functional app appears. The internet proclaims: coding is dead. Programmers are obsolete. The age of AGI has arrived.
But here’s the uncomfortable truth that nobody wants to hear: LLMs are not a revolution. They are just the latest, most polished abstraction layer—exactly like the low-code and no-code platforms that came before. The hype is a lie, but not because the technology is bad. Because we’ve seen this movie before, and we keep forgetting the ending.
You’ve probably noticed that the people celebrating AI coding the loudest are not the ones actually shipping production software. They’re marketers, VCs, and Twitter thought leaders. Meanwhile, the engineers who actually use LLMs daily will tell you a different story: the real bottleneck isn’t the model’s ability to generate code. It’s your ability to specify intent precisely and then debug the output.
That sounds exactly like every low-code platform from the past decade. Remember OutSystems? Mendix? Microsoft Power Apps? They all promised to democratize software creation. And they did—for simple use cases. But the moment you needed custom logic, error handling, or integration with existing systems, you hit a wall. Suddenly, you needed a real developer to untangle the abstraction.
LLMs are the same, except they swap drag-and-drop for natural language. The wall is just painted prettier.
I watched a product manager spend three hours prompting an LLM to build a client dashboard. Every iteration produced something that looked right but behaved wrong. He couldn’t tell the difference between a bug in the prompt and a misunderstanding of the business logic. Finally, he gave up. The bottleneck wasn’t the AI. It was the gap between what he thought he wanted and what he actually needed.
This is the deflation that nobody talks about. The emotion isn’t awe—it’s frustration. The promise of “just talk to your computer” crumbles under the weight of ambiguity. Low-code taught us that abstraction comes at a price: you lose control. LLMs are no different. They trade predictability for fluidity, and the trade-off is brutal when things go wrong.
So here’s the side I’m taking: This is not a revolution. It’s an evolution. And that’s actually good news—if you stop believing the hype. LLMs won’t replace programmers. They’ll replace the skill of writing syntax with the skill of writing specifications. That’s a shift, not a death blow. The developer who understands domain logic, edge cases, and system architecture will still be the one in charge. The prompt jockey will be the new low-code citizen developer—empowered for simple tasks, stranded on complex ones.
We’ve seen this cycle before. Every decade, a new abstraction layer emerges: assembly → C → Java → JavaScript frameworks → low-code → LLMs. Each one makes programming more accessible. Each one creates new jobs for those who understand what’s underneath. The same forces that gave us “No Code” are now giving us “No Prompt.” But neither eliminates the need for disciplined thinking.
The next time someone tells you that AI is about to make all developers obsolete, remember: we’ve seen this movie before. It was called low-code, and it didn’t kill programming. It just made more people able to participate. LLMs are the same story, but with better marketing—and a worse hangover when the hype fades.
FAQ
Q: If LLMs are just like low-code, why are they so much more impressive?
A: Because natural language feels more magical than drag-and-drop. But the underlying dynamics are identical: you trade control for speed, and you hit a wall the moment your intent becomes complex. The impressiveness of a demo rarely survives contact with real-world edge cases.
Q: So should I stop using LLMs for coding?
A: No—use them aggressively for prototyping, boilerplate, and exploration. Just don't mistake them for a replacement for engineering discipline. Treat the output as a first draft that requires the same debugging, testing, and architectural thinking as any other code.
Q: Aren't LLMs fundamentally different because they understand natural language?
A: Understanding natural language is just a better user interface. It doesn't change the hard part: specifying what you want clearly and completely. That's still a human skill—one that low-code failed to eliminate and that LLMs will fail to eliminate too. The interface changes; the bottleneck stays.