Let's not forget what we learned
There’s a familiar cycle in tech, and if you’ve been here a while, you know the melody. The domains where AI is surging - customer support, basic data entry, routine workflows - are the exact same ones we’ve promised to “revolutionize” since the first IVR told you to press 1 for billing. Tools evolve. The pitch stays the same.
This time, though, something is genuinely different. And we’re at serious risk of wasting it.
AI in Skilled Hands Is a True Force Multiplier
Make no mistake: for engineers who deeply understand their domain, architecture, and users, AI is transformative. I’ve watched it happen. They ship faster, explore ideas more rapidly, eliminate drudgery, and spend real time on problems that matter. That’s powerful.
In less experienced hands? Far less so. Which brings us to “vibe coding”, of which I am a fan, however...
The Hard Lessons from Low-Code We Shouldn’t Unlearn
Low-code platforms taught us durable truths through years of real-world use - what scales, what becomes a nightmare. Before we treat prompt-to-code as the new frontier, recall what actually worked:
- Reusable, battle-tested building blocks: identity, auth, forms, validation, workflows - Lego, not loose plastic (see I ♥ Lego)
- Automatic, platform-level upgrades: new capabilities (real-time, offline, mobile responsiveness) delivered without rewriting your app (see You don't want a mobile app)
- Inherent maintainability: high-level abstractions and standards kept the platform responsible for the heavy lifting (see Design like Apple)
Today’s vibe coding discards all of that. It generates raw code, not composable abstractions. No platform upgrades your output. The maintenance burden lands squarely on you.
It doesn’t have to be this binary.
A Better Path: Amplify What Worked
What if we used AI to extend the low-code tradition instead of replicating its failures in a new skin?
Imagine AI that:
- Intelligently composes proven building blocks
- Understands and respects the underlying abstractions
- Produces applications that remain automatically upgradable because they’re built on solid foundations, not one-off spaghetti
That future delivers the speed people crave and the longevity businesses need. The dopamine hit of “I built an app in 10 minutes” is tempting - but fleeting.
Software Is More Than Running Code
The vibe-coding narrative quietly downgrades what good software really is. It’s not just syntax that compiles. It’s the hard-won distillation of deep domain knowledge, careful thinking about how concepts interact, empathy for users, and thousands of small decisions about what actually works.
Every great application encodes tens of thousands of deliberate choices.
Look at Qualified (recently acquired by Salesforce ): you’re not just getting code - you’re getting decades of accumulated insight from people like Kraig Swensrud and Sean Whiteley , who ran world-class marketing orgs (including Kraig being CMO at Salesforce). You can’t vibe-code that depth. You shouldn’t try. But you can build AI that helps domain experts like them move faster, codify their knowledge better, and deliver more value.
Innovation Still Requires Depth
The applications landscape isn’t slowing. Building “another Salesforce” won’t disrupt anyone. Disruption comes from solving unsolved problems better - with real insight, not just prompts.
The work Jaya Gupta recently shared is a perfect example: thoughtful, purposeful software built by professionals who understand both the tech and the domain, now supercharged by AI. That’s expertise amplified - not vibe coding. Her blog is a rallying call for innovation backed by deep domain expertise.
Let’s Not Repeat the Access Database Era, but way worse
Tools like Lovable make spinning up websites, forms, and lists trivial. But how many businesses want to own and maintain thousands of custom, vibe-coded mini-apps when mature alternatives already exist?
I once spoke with a Fortune 500 customer that had 50,000+ Access databases - each a well-intentioned shadow-IT solution, now a sprawling security and maintenance liability. We’re already on track to recreate that pattern at scale.
The Choice Ahead
AI is already revolutionizing software development for skilled practitioners. The question is where we steer it.
We can generate mountains of unmaintainable code that ignores decades of lessons. Or we can use AI to strengthen the principles that actually endured: composable building blocks, automatic upgrades, maintainability, and the irreplaceable expertise of people who truly understand their domains.
I know which path I’m choosing.
Let’s not forget what we learned.
