By a senior developer who has spent more time than he'd like to admit arguing with an AI about semicolons.
There's a moment every developer has experienced at least once this past year. You're staring at a blank file, you type a rough description of what you want — maybe something like "build me a dashboard that pulls in Stripe data and shows monthly revenue trends" — and twenty seconds later, the AI hands you back a working component. Not a skeleton. Not boilerplate. Something close enough to real that you feel slightly unnerved.
That feeling — that mix of wonder and mild existential dread — is the entry point to what the industry has started calling vibe coding.
And it's no longer a fringe experiment. It's how a significant slice of the developer world builds software now.
So What Actually Is Vibe Coding?
The term was coined in February 2025 by Andrej Karpathy — former head of AI at Tesla, ex-OpenAI researcher — in a now-famous tweet where he described a workflow where you "fully give in to the vibes, embrace exponentials, and forget that the code even exists." You describe intent in natural language. The AI generates the implementation. When something breaks, you paste the error back in and let the model fix it. The developer's job shifts from writing code to directing it.
The phrase is deliberately irreverent, and that's the point. Traditional programming was a discipline of precision. Every bracket had to close. Every null had to be handled. Vibe coding inverts that: you describe the feeling of what you want to build, and the machine figures out the how.
It sounds almost like a joke. But here's the thing — it works. Not always cleanly, not always safely, but often well enough to ship.
The Rise Was Fast. Faster Than Most People Realize.
We tend to think of technological paradigm shifts as slow, grinding affairs. Vibe coding moved at the pace of a startup.
In early 2025, GitHub Copilot was already ubiquitous. But Copilot was autocomplete on steroids — it helped you write code you already understood. The shift happened when tools like Cursor, Claude Code, and Replit's AI agent arrived and started reasoning about entire codebases, not just the line you were currently typing.
By March 2025, Y Combinator's managing partner Jared Friedman revealed something that stopped the developer community cold: a quarter of startups in YC's Winter 2025 batch had codebases that were 95% AI-generated. These weren't non-technical founders winging it. YC CEO Garry Tan was clear: "Every one of these people is highly technical, completely capable of building their own products from scratch. A year ago, they would have built their product from scratch — but now 95% of it is built by an AI."
That batch, collectively, grew at 10% per week — numbers Tan said had never been seen before in early-stage venture. The correlation between AI-assisted development and speed-to-market wasn't theoretical. It was showing up in revenue curves.
Meanwhile, platforms like Vercel and Netlify began reporting massive surges in their user bases — driven not by professional developers signing up, but by an entirely new category of builder who had never written a for loop in their life.
Why Developers Embraced It — And Why Non-Developers Jumped In Too
For working developers, the appeal is visceral and practical. Boilerplate is tedious. Scaffolding is boring. Setting up auth, writing CRUD routes, wiring up a database schema — these tasks exist because they must exist, not because they're intellectually interesting. AI-assisted development tools handle this without complaint. That frees the developer's brain for the parts that actually require judgment: architecture, tradeoffs, product thinking, edge cases that the AI reliably misses.
The productivity gains are real. In the early phases of a project — when speed matters most and standards haven't fully hardened — vibe coding is a genuine accelerator. Solo founders are launching MVPs in days instead of months. Small teams are punching well above their weight class. Pieter Levels built an MMO flight simulator in 30 minutes using AI tools; it scaled to hundreds of thousands of users and generates over $50,000 a month.
But the more interesting story is what happened to people who never considered themselves developers at all.
By mid-2025, 63% of active vibe coders were non-developers. Marketers, designers, product managers, solopreneurs — people who had ideas but no path to execute them — discovered that the gap between "I want to build something" and "something exists" had collapsed almost entirely. Tools like Bolt, v0 by Vercel, and Lovable let you describe an interface in plain English and receive a deployable component in return. The line between "coder" and "creator" didn't just blur — it started to dissolve.
Andrew Chen, a prominent tech investor, captured the trajectory neatly: most code in the near future will be written by the time-rich rather than the technically trained — students, hobbyists, first-time founders, people who simply have ideas and the patience to prompt.
The Real Benefits Go Deeper Than Speed
Speed is the headline. But the structural advantages of AI-assisted development run deeper and they're worth thinking through carefully.
Lower cost of experimentation. When implementing an idea takes hours instead of weeks, you can afford to be wrong more often. You can test three approaches instead of betting everything on one. This fundamentally changes how products get built — it shifts the bottleneck from engineering capacity to product clarity.
Democratization of building. This is significant in ways that haven't fully landed yet. For decades, the ability to build software was gated by years of training. That gate is now much lower. A first-generation college student with no CS background can now build and ship a functional product. That unlocks a lot of human potential that the traditional industry structure left on the table.
Developer focus on what matters. When AI handles the scaffolding, developers get to spend more time on the things that actually require their expertise: system design, performance optimization, security review, architectural decisions. In theory — and increasingly in practice — that makes the work more interesting, not less.
But the Hangover Is Real
By September 2025, Fast Company was already reporting on the "vibe coding hangover." Senior engineers were describing working with AI-generated codebases as entering a kind of development hell — code that works but is barely comprehensible, loosely coupled, resistant to modification, and riddled with subtle edge cases that only surface under production load.
This isn't a hypothetical concern. The research is damning in places. A randomized controlled trial conducted by METR in July 2025 found that experienced open-source developers were actually 19% slower when using AI coding tools — despite predicting they'd be 24% faster and still believing afterward they had been 20% faster. The subjective feeling of velocity masked a measurable slowdown in outcomes.
The security picture is worse. A 2025 Veracode study found that while AI models had become dramatically better at generating functional code over three years, the security of that code had shown essentially no improvement. In May 2025, Lovable — a Swedish vibe coding platform — was found to have security vulnerabilities in 170 of 1,645 applications it generated. A December 2025 security researcher discovered a flaw in another vibe coding platform and demonstrated it live to a BBC reporter.
The underlying problem is accountability. When you write code, you understand it — or at least you're responsible for understanding it. When AI writes code, that responsibility becomes diffuse. Developers may ship AI-generated logic they can't fully explain, carrying bugs and vulnerabilities they can't detect. A January 2026 academic paper titled "Vibe Coding Kills Open Source" argued that the trend was quietly eroding the engagement between developers and open-source maintainers — one of the hidden social contracts that keeps critical infrastructure running.
Andrew Ng, one of the most respected voices in AI, took explicit issue with the term itself, arguing it misleads people into assuming that professional developers are just going with the vibes — as if judgment and rigor have become optional.
They haven't.
How the Developer's Role Is Actually Changing
Here's where it gets philosophically interesting.
The framing of "AI will replace developers" misses the actual transformation. What's happening is a layer shift. The work isn't disappearing — it's moving up the abstraction ladder.
The developers seeing the best outcomes aren't those blindly trusting AI output, and they're not the ones refusing to use it either. They're the ones who've learned to work with AI like a senior engineer works with a talented but overconfident junior: you give clear direction, you review the output, you push back on the sloppy parts, and you remain the person responsible for the result.
Varun Mohan, CEO of Windsurf, described the shift cleanly: developers are becoming "system architects, orchestrating intelligent agents that write and optimize code on their behalf." That's not a downgrade. It's a different kind of expertise. The question changes from how do I implement this to what should this system do, how should it be structured, and how will it fail.
Gene Kim — author of The Phoenix Project — put it well at AI Native DevCon: the developers getting the best results out of AI tools were the ones who wrote lightweight specifications before handing work to agents. They invested in tests. They treated AI output as code they owned, not code they downloaded. The discipline didn't disappear. It just moved earlier in the process.
Prompt engineering — once dismissed as a buzzword — is emerging as a genuine craft. Knowing how to structure a prompt, chain instructions, provide constraints, and iterate on output is becoming as valuable on some teams as knowing how to write the code itself. Prompt libraries and reusable patterns are becoming team artifacts, managed and versioned like any other codebase artifact.
What This Means for Startups and Teams
The implications for how software businesses are built are significant and still unfolding.
The team size required to build a functional product has dropped. This isn't speculation — YC's Winter 2025 cohort demonstrated it empirically. Solo founders are shipping products that would have required a 5-person engineering team two years ago. Two-person startups are moving at the pace previously associated with Series A companies.
This changes the economics of starting a software company in a fundamental way. The idea that you need to raise a seed round to hire three engineers before you can test a hypothesis is becoming increasingly questionable. You can now validate much further before you need capital — which changes the leverage dynamics between founders and investors.
For established engineering teams, the implications are different. The risk isn't mass layoffs — it's a quiet reshaping of who gets hired and what gets valued. Junior developers whose core contribution was writing well-understood implementations are facing genuine headwinds. At the same time, developers who can architect systems, review AI output critically, and maintain quality standards under speed pressure are more valuable than ever.
The nature of technical debt is also changing. Traditional tech debt was at least legible — you knew you'd cut corners on the refactor. AI-generated tech debt is often invisible until it isn't. Code that works in demos may be deeply fragile. This is creating a new role: the AI code reviewer, someone whose job is explicitly to understand and audit what the machine produced.
Real Examples Worth Paying Attention To
A few specific cases illustrate where the curve is heading.
Pieter Levels and fly.pieter.com — a solo developer who built a multiplayer flight simulator using AI tools in roughly 30 minutes. It scaled to hundreds of thousands of users and generates meaningful monthly revenue. The project became something of a proof-of-concept for the "Minimum Vibable Product" — an MVP built not through months of careful engineering but through rapid iterative prompting.
YC W25 cohort — as detailed above, a quarter of the batch leaned heavily on AI-generated codebases and collectively achieved 10% week-over-week growth. Garry Tan's verdict was direct: "This isn't a fad. This is the dominant way to code."
Linus Torvalds — as of January 2026, even the creator of Linux noted in a README file that the Python visualizer component of his AudioNoise project had been "basically written by vibe-coding." If Linus is doing it, it's mainstream.
Steve Yegge, documented in Gene Kim's research, was producing 12,000 lines of tested code per day using 3-4 AI agents in parallel — numbers that simply weren't achievable with any previous toolchain.
Practical Advice for Developers Navigating This Shift
If you're a developer trying to figure out how to stay relevant, relevant, and honest about what's happening — here's what the evidence actually suggests:
Use the tools. Seriously. The developers who understand AI coding tools from the inside have a structural advantage over those who don't. You can't review AI output competently if you've never watched how it fails.
Invest heavily in testing. Test-driven development becomes exponentially more valuable in an AI-assisted workflow. Tests give the AI a specification to work toward. They give you a tripwire for the subtle bugs it introduces. If you don't have a robust testing practice, start building one now.
Write specifications before prompting. The developers producing the best outcomes write a lightweight spec — a clear description of the system's requirements, constraints, and expected behaviors — before they start prompting. It forces clarity of thought and gives the AI something coherent to work from.
Understand the code you ship. This sounds basic, but it's genuinely under threat in a vibe-coding workflow. Make it a personal rule: if you can't explain how the code works to a colleague, it doesn't ship. This is the discipline that separates professionals from prompt jockeys.
Learn system design deeply. As implementation becomes increasingly delegated, the value of knowing how to design systems — how to choose between architectures, identify bottlenecks before they appear, think about failure modes — goes up, not down.
Security is your responsibility now. AI tools don't get better at generating secure code as they get more capable. Until that changes, security review is a human job. Build that habit explicitly.
The Future Is Collaborative, Not Replaced
Here's the honest picture as we stand in early 2026: vibe coding has crossed the threshold from trend to infrastructure. The developer platforms are seeing it in user growth. The startup accelerators are seeing it in codebase composition. The enterprise tools market is seeing it in procurement decisions.
But the narrative that AI "replaces" developers remains a misread of what's actually happening. The more accurate framing is that the job description is shifting. The ceiling is rising — one developer can now cover more surface area than before. But the floor is also rising: the minimum viable understanding required to ship good software remains stubbornly non-zero, and in some ways the bar for architectural judgment and critical review has gone up, not down.
The developers who will thrive in the next decade are those who become fluent in this new kind of collaboration. Not skeptics who refuse to use AI because the output is imperfect, and not evangelists who accept AI output without scrutiny. The winning posture is something harder to achieve than either extreme: genuine expertise wielded through a new set of tools.
Think of it the way great editors think about writing. The editor's job isn't to write every sentence — it's to understand what good sentences look like, know when the draft isn't hitting that bar, and have the skill to improve it. The AI is the fast, tireless, sometimes brilliant, occasionally reckless first drafter.
The developer who knows what good code looks like, understands the system it needs to fit into, and can guide and review the machine's output — that developer is not being replaced.
That developer is just getting a very powerful new collaborator.
The question isn't whether vibe coding will reshape software development. It already has. The question is whether you're building the skills to be the person who directs it — or whether you're letting the vibes do all the thinking.
Top comments (0)