There’s a phrase that’s taken hold in the AI world: “vibe coding.” It means building software by describing what you want in plain English and letting an AI generate the code. The term sounds playful, even dismissive, like something teenagers do for weekend projects. But underneath the whimsy, something serious is happening.
Three different groups of people are watching the same wave approach, and they’re all terrified for different reasons.
The first group works at SaaS companies.
These are the people who built the software layer of the economy over the past two decades. They created products that became verb-ified: Slacking, Zooming, Salesforcing.
Now their marketing departments are frantically “slapping AI over their marketecture” (a phrase I love for its honest brutality). They’re adding chatbots to dashboards, sprinkling “powered by AI” badges across landing pages, and praying customers don’t notice that the core product hasn’t fundamentally changed.
The frustration here is existential but diffuse. You know the wave is coming, but you’re not sure which part of your product it will dissolve first. Is it the search function? The reporting layer? The entire reason customers pay you? Every feature roadmap meeting now includes a silent calculation: how long until an AI agent can do this for free?
The cruelest part is that the better your product is documented, the easier it is to replace. All those years of building intuitive UX and clear workflows created the perfect training data for your own displacement.
The second group is the open source maintainers. These are the monks of software, people who’ve spent years building libraries and packages used by millions, often without compensation beyond GitHub stars and occasional conference invitations.
Their frustration is more personal. Suddenly their inboxes are flooded with pull requests that look plausible but feel wrong. Code that compiles but doesn’t quite grok the philosophy of the project. Variable names that seem machine-generated because they are. Comments that explain what the code does rather than why it exists.
“AI slop” is what they call it, and the term captures something important. It’s not that the contributions are useless; it’s that they’re soulless. They add surface area without adding value. Every PR that needs to be reviewed, rejected, and explained is time stolen from actual development.
But here’s the deeper fear: someone could rewrite your entire library in a weekend. Not better, necessarily, but good enough. The years you spent understanding edge cases and making deliberate tradeoffs—a sufficiently motivated person with Claude access can now vibe their way to a reasonable facsimile. Your expertise became pattern-matchable.
The third group is building new startups. They’re supposed to be the nimble ones, the disruptors, the people who should benefit most from powerful new tools. Instead, they’re discovering a peculiar problem: the moment their product works, the frontier models notice.
This is new. Historically, successful startups had time. You could carve out a niche, build customer relationships, and create switching costs before the incumbents woke up. But OpenAI and Anthropic are watching. Not in some sinister way—they’re simply building toward general capability, and general capability eventually includes whatever your vertical does.
Healthcare AI startup gaining traction? Interesting—Claude could probably do that. Legal document analysis showing promise? That’s a natural extension of language understanding. Your successful product is essentially a suggestion box for the next model training run.
The frustration here is the impossibility of moats. Every defensive strategy feels temporary. Proprietary data? Models are getting better at reasoning with less. Distribution advantages? AI agents are starting to interact with software directly. Brand trust? That’s real, but it’s not enough to build a company on.
These three frustrations look different but share a common root: the collapse of the expertise gap.
For decades, knowing how to do something was enough. If you understood how to write software, you had a skill that commanded premium compensation. If you understood how software was supposed to behave, you could build products people would pay for. If you understood the deep patterns in a domain, you could maintain code that others relied on.
Now the tools know too. Not perfectly, but well enough that the gap between an expert and an enthusiastic amateur has narrowed dramatically. A person who’s never written Python can vibe-code a working web application in an afternoon. Someone who’s never studied healthcare regulation can prompt their way to a reasonable first draft of a compliance document.
This sounds like a threat, and it is. But it’s also an illusion.
Here’s the thing about Home Depot. They sell the same power tools that professional contractors use. The DeWalt drill on the shelf is identical to the one in a construction crew’s truck. But if you gave a homeowner and a contractor the same drill and the same blueprints, you’d get very different houses.
The tool isn’t the skill. The skill is knowing when to use it, how hard to push, where the material will give, what the building code actually requires, and which shortcuts will haunt you in five years. The homeowner has to figure this out through trial and error. The contractor has it compiled into instinct.
The same dynamic applies to AI tools. Yes, everyone has access to Claude. Yes, a novice can vibe-code an application. But there’s a spectrum of proficiency that determines whether that application is a toy or a product, whether it handles edge cases or crashes in production, whether it delights users or merely functions.
I’ve been calling this the gap between explorers and experts. Explorers use AI to venture into unfamiliar territory. They’re discovering what’s possible, building things they couldn’t build before, learning at remarkable speed. Experts use AI to amplify skills they already have. They know what good looks like, so they can guide the model toward it. They catch errors that explorers would ship.
Both groups are getting value, but they’re getting different kinds of value, and the gap between their outputs can be enormous.
This is where things get interesting. Palantir pioneered something called “forward deployed engineers”—technical people who embed with customers rather than sitting at headquarters writing code. Their job was to bridge the gap between what the software could do and what the customer actually needed.
That role is about to become much more important, but with a twist. The new forward deployed engineers won’t just bridge the gap between software and customer. They’ll bridge the gap between AI capability and practical deployment. Their job will be to take what’s possible with these tools and make it real, to reduce the variance between what an explorer builds and what an expert would build.
The question is: where are these people, and what artifacts do they leave behind?
When a great forward deployed engineer solves a problem, they don’t just solve it once. They create patterns that can be reused. Templates. Workflows. Documented approaches. What Palantir calls “solutions” but what might better be called “crystallized expertise.”
The AI equivalent would be prompts, tool configurations, and agent architectures that encode professional judgment. Not just “ask Claude to write code,” but “here’s how to ask Claude to write code that handles authentication correctly, fails gracefully, and won’t embarrass you when security researchers take a look.”
This brings us back to the three frustrated groups.
The SaaS companies aren’t threatened by AI features. They’re threatened by the possibility that AI agents will make their interfaces irrelevant. But the companies that figure out how to encode professional expertise into their products—not just AI capabilities, but judgment about when and how to apply them—will survive the transition. They’ll become the place where explorers go to develop expert-level instincts.
The open source maintainers aren’t threatened by AI slop. They’re threatened by the possibility that curation becomes impossible, that the signal-to-noise ratio destroys community. But maintainers who develop clear frameworks for what good contributions look like—and AI tools that help contributors meet those standards before submitting—will build more vibrant projects than ever.
The startup founders aren’t threatened by frontier models eating their vertical. They’re threatened by building something that requires no specialized knowledge to replicate. But founders who embed genuine expertise into their products—who create tools that make everyone more expert, not just more capable—will find that the frontier models become their distribution channel rather than their competition.
The world we’re heading toward isn’t one where everyone is equally capable. It’s one where the nature of capability has changed. Knowing how to do something matters less than knowing what should be done. Execution is becoming abundant; judgment is becoming scarce.
This might sound like bad news if you’ve spent your career building execution skills. But judgment is just execution that’s been internalized so deeply it feels like instinct. And the fastest way to develop judgment is to execute a lot, ideally with tools that accelerate your learning.
The explorers will become experts, faster than experts became experts under the old regime. The tools leave trails. Every vibe-coded project teaches something about what works. Every AI-assisted debug session reveals patterns. The gap between explorers and experts will continue to narrow, not because experts are getting worse, but because explorers are climbing faster.
So here’s the actual situation: we’re in a moment where the rules are being rewritten, but the rewriting isn’t complete. The people who figure out how to encode expertise into transferable artifacts will shape what comes next. Not the raw AI capabilities—those belong to the model providers. But the patterns of application, the judgment frameworks, the crystallized wisdom about what makes something good.
The SaaS executive, the open source maintainer, the startup founder—they’re all asking the same question, just in different dialects. The question is: in a world where everyone can vibe it, what makes someone worth listening to?
The answer, as it has always been, is taste. The ability to tell the difference between something that works and something that’s good. The judgment to know when the AI is hallucinating versus when it’s seeing something you missed. The experience to recognize patterns that haven’t been codified yet.
Let’s vibe it, sure. But let’s also remember: the vibe is only as good as the person setting the direction.