In March 2026, Apple started quietly pulling apps from the App Store. Not by the dozens, but by the thousands. The common thread? They were all built using what Andrej Karpathy had dubbed “vibe coding” a year earlier: apps generated almost entirely through natural language prompts to AI, with minimal human oversight.
The purge caught many aspiring developers off guard. After all, the AI tools had promised anyone could build software now. Type what you want, get working code, ship it to users. The dream of democratized software development seemed within reach. But the App Store crackdown exposed something the hype had glossed over: there’s a gulf between code that runs and code you can actually ship.
When “It Works” Stops Being Enough
The apps Apple removed weren’t necessarily broken. Many functioned exactly as intended when submitted. But they shared patterns that reviewers flagged: inconsistent error handling, security vulnerabilities in authentication flows, memory leaks that would surface after extended use, accessibility features that technically existed but didn’t actually work for screen reader users.
These weren’t bugs in the traditional sense. They were gaps. The kind that appear when you describe what you want software to do, but don’t understand the hundred invisible requirements that production software needs to satisfy. AI can implement the features you ask for. It can’t anticipate the requirements you don’t know to ask about.
The distinction matters more than it might seem. When you tell an AI to “add user authentication,” it will generate code that authenticates users. What it probably won’t do, unless you specifically prompt for it, is implement rate limiting to prevent brute force attacks, handle edge cases like password resets during network failures, or ensure tokens are properly invalidated across sessions. These aren’t exotic requirements. They’re table stakes for production software. But they require knowing they exist in the first place.
The Responsibility Problem
The real issue that surfaced in 2026 wasn’t whether AI could write code. That question had been settled. The question was: who takes responsibility when that code ships?
Professional developers caught on quickly to how AI tools could accelerate their work. A senior engineer using Cursor or Copilot could scaffold out boilerplate, generate test cases, and refactor complex logic faster than ever before. But they were still reading every line. Still considering security implications. Still thinking about how changes would interact with the rest of the codebase. The AI became a force multiplier for people who already knew what questions to ask.
Vibe coding flipped that dynamic. It put the AI in the driver’s seat, with the human simply describing destinations. For personal projects or quick prototypes, this worked beautifully. For production software that other people would depend on, it created a category of maintainers who couldn’t maintain what they’d shipped.
The App Store removals weren’t punitive. They were pragmatic. Apple couldn’t allow its platform to fill with apps that would accumulate unpatched vulnerabilities because their creators didn’t understand what needed patching. The company faced a choice between defending the vibe coding movement’s promise of universal access and protecting users from software that worked in demos but failed in the field.
Where Vibe Coding Actually Shines
None of this means vibe coding is a failed experiment. But it does suggest its real value lies in different domains than the ones the initial hype targeted.
Rapid prototyping might be the clearest win. When you need to validate an idea quickly, vibe coding gets you to a working demo faster than any previous approach. The code won’t be production-ready, but production-readiness isn’t the goal. You’re testing whether users want the feature, not whether it can scale to a million users.
Personal-use software represents another natural fit. Building tools for yourself removes most of the responsibility problem. You understand the context. You can work around quirks. If something breaks, you’re the only one affected. The barrier to creating custom scripts and utilities has dropped from “learn programming” to “describe what you want clearly.” That’s a meaningful shift for people who need software solutions but don’t need software careers.
As a learning tool, vibe coding occupies interesting territory. Critics point out that generating code you don’t understand teaches you nothing. That’s true. But watching AI generate code while you’re learning teaches you something different: what the end result should look like. For beginners, seeing working code can demystify programming in ways that tutorials sometimes don’t. The key is treating it as a reference, not a shortcut.
The Tool Landscape in 2026
The market has already started differentiating itself along the spectrum between traditional programming and pure vibe coding.
Cursor and similar tools target professional developers. They integrate into existing workflows, provide suggestions in context, and assume you’re reading and evaluating their output. The value proposition isn’t “you don’t need to code anymore.” It’s “you can code faster and handle more complexity.”
Windsurf-style tools aim somewhere in the middle. They handle more of the architectural decisions but still expect you to understand what you’re building. The balance works well for developers with some experience who want to move faster without giving up control.
Replit and v0 pushed further toward pure vibe coding, generating entire interfaces from descriptions. These tools excel at certain use cases, particularly UI work where visual feedback lets non-technical users iterate toward what they want. But they run into the responsibility wall faster when you try to ship what they generate.
Terminal-based tools like Claude Code and Codex CLI carved out another niche. They assume technical users who prefer working in text but want AI assistance for routine tasks. The interface is different, but the dynamic resembles Cursor: AI as assistant, human as architect.
The Middle Path
The vibe coding debate has settled into familiar battle lines: skeptics declaring it proves nothing has really changed, advocates insisting critics just don’t get it. Both positions miss something.
Vibe coding didn’t end programming. But it did create a new entry point that works for certain contexts. The mistake was assuming that entry point led straight to production software without intermediate steps.
The developers seeing the biggest productivity gains in 2026 aren’t picking sides. They’re using AI tools that match their context. Vibe coding for throwaway prototypes. AI-assisted development for production work. Traditional programming when they need to understand every line. The tools enable different workflows. The skill lies in knowing which workflow fits your situation.
What Apple’s crackdown clarified is that lowering barriers to entry doesn’t eliminate responsibility for what you ship. Vibe coding makes it possible to generate code without understanding it. That’s fine for personal projects. For software other people depend on, understanding remains non-negotiable.
The future probably doesn’t involve picking between traditional programming and vibe coding. It involves recognizing them as different points on a spectrum, useful for different purposes. Code generation tools will keep improving. So will the tools that help developers understand and modify generated code. The gap between “it runs” and “it ships” will narrow, but likely never close completely.
Because at some level, shipping software has always required someone who understands what they’re responsible for. AI can write the code. It can’t sign off on whether that code should run on a user’s device. That judgment still requires the kind of understanding that comes from knowing not just what you built, but what could go wrong.
The question facing the industry isn’t whether vibe coding has a place. It clearly does. The question is whether we can resist the temptation to oversell that place, to claim tools that lower barriers have eliminated them entirely. The App Store purge of 2026 suggests we’re still learning that lesson.
Stay updated with our latest AI insights
