The Impact of AI on Vibe Coding

The Good, The Bad, and the Ugly of Vibe Coding Andrej Karpathy coined "vibe coding" in February 2025. Within a month, Merriam-Webster added it to the dictionary. By March, 25% of Y Combinator startups had codebases that were 95% AI-generated. Almost eight months later, reality is setting in. ➡️ The Good You describe what you want in plain English. AI writes the code. No syntax knowledge required. The speed is real. Replit's ARR jumped from $10 million to $100 million in nine months. Small businesses now build tools that would have cost $50,000 and six months. People in Nairobi, Mumbai, and Lagos are shipping products that wouldn't otherwise exist. More ideas get tested. More diverse voices get heard. ➡️ The Bad Vibe coding hits a complexity ceiling fast. Works for prototypes. Breaks when you need scale or security. Fastly surveyed developers: 95% spend extra time fixing AI-generated code. Stack Overflow reports 46% of professional developers distrust AI coding tools. Only 30% say these tools handle complex tasks well. The Tea app left 72,000 sensitive images exposed. Security researchers blame AI-generated code. Lovable had vulnerabilities in 170 out of 1,645 apps it created. ➡️ The Ugly Senior engineers are becoming "AI babysitters." Some companies now hire "vibe code cleanup specialists." PayPal engineer Jack Zante Hays calls AI codebases "development hell." The code creates technical debt faster than teams pay it down. Coinbase CEO Brian Armstrong bragged that nearly half his exchange's code is AI-generated. The developer community responded with ridicule. Fast Company reported in September that senior engineers cite "development hell," "toxic waste," and "evil genies" when describing vibe-coded projects. Simon Willison: "If an LLM wrote every line but you've reviewed, tested, and understood it all, that's not vibe coding. That's using an LLM as a typing assistant." ⭐️ What This Means Vibe coding works for weekend projects and internal tools. Use it to test ideas quickly. Stop there. When you handle user data, need security, or want scale, bring in people who understand the code. AI generates fast. Humans ensure it works safely. Don't ship code you don't understand to production systems that matter. ➡️ Where We Go From Here I've spent 25 years in digital strategy. Every new tool follows the same pattern. Early adopters claim it changes everything. Reality sets in. We figure out what it's good for. Vibe coding democratizes prototyping. That's valuable. But it does not replace understanding how systems work, how security functions, or how to maintain code. Use AI tools to move faster on the right things. Don't use them to skip the hard work of building software that matters. The companies that will win long-term are figuring out how to move vibe-coded prototypes into production without creating technical debt. We're almost eight months into this experiment. The honeymoon is over. The real work begins.

I’ve been running a quiet experiment: using AI coding (Vibe Coding) across 10 different closed-loop production projects — from minor refactors to major migrations. In each, I varied the level of AI involvement, from 10% to 80%. Here’s what I found: The sweet spot? 40–55% AI involvement. Enough to accelerate repetitive or structural work, but not so much that the codebase starts to hallucinate or drift. Where AI shines: - Boilerplate and framework code - Large-scale refactors - Migration scaffolds - Test case generation Where it stumbles: - Complex logic paths - Context-heavy features - Anything requiring real systems thinking [and new architectures etc]. - Anything stateful or edge-case-heavy I tracked bugs and % of total dev time spent fixing AI-generated code across each project. Here's the chart. My learning is that: overreliance on AI doesn’t just plateau, it backfires. AI doesn't write perfect code. The future is a collaboration, not a handoff. Would love to hear how others are navigating this balance. #LLM #VibeCoding #AI #DeveloperTools #Dev

I've been experimenting with "vibe coding" for a while now, and here's what I've learned. The honeymoon phase is incredible. Those first few AI-generated solutions feel like magic - clean, functional code appearing in seconds. But there are consequences. No free lunch. When you need to debug, extend, or maintain that code, you're essentially inheriting someone else's work - except that "someone" is an AI. I found myself spending more time trying to understand AI-generated code than I would have spent writing it myself. And then the errors and bugs that show up in production and the initial speed boost gets eaten up by the maintenance burden. It has now happened multiple times where some null pointer remains, or AI ends up sorting a list in some wrong way or we just have a solution that looks right but doesn’t take care of all cases. So, AI is an amazing tool for boilerplate, quick prototypes, and learning new patterns. But for production code you'll need to live with long-term, there's still no substitute for understanding every line you ship. The sweet spot seems to be collaborative coding - using AI as a sophisticated autocomplete and brainstorming partner, not as a replacement for deep technical thinking. That has atleast been my experience. Would love to hear your experiences with AI coding tools.

𝗙𝗿𝗼𝗺 𝗩𝗶𝗯𝗲 𝗖𝗼𝗱𝗶𝗻𝗴 𝘁𝗼 𝗧𝗿𝗶𝗯𝗲 𝗖𝗼𝗱𝗶𝗻𝗴 AI coding tools have quietly dismantled one of software development’s strongest gates: the ability to write code. For decades, software was the domain of trained programmers. Domain experts explained what they wanted, but turning intent into systems required a technical intermediary. That dynamic has changed. With tools like #Cursor, business and domain experts now build software directly. They describe intent, iterate conversationally, and let models handle syntax, scaffolding, and boilerplate. This “vibe coding” approach has been surprisingly effective. People who never saw themselves as programmers are shipping internal tools, automations, dashboards, and even customer-facing apps. The playing field has been levelled. But the dynamics change when we move from small tools to serious systems. Vibe coding works best for bounded problems: a workflow automation, a reporting app, a quick prototype. Speed matters more than structure, and mistakes are cheap. The AI fills gaps while humans focus on intent. Enterprise-grade applications are different. They live longer. They scale unpredictably. They integrate with messy systems. They must be secure, testable, and maintainable. Here, vibe coding alone starts to strain. Not because AI cannot generate code, but because quality software is about architecture, failure modes, testing discipline, data contracts, and long-term ownership. This is where we need a new model. Not instead of vibe coding, but on top of it. I call it 𝗧𝗿𝗶𝗯𝗲 𝗖𝗼𝗱𝗶𝗻𝗴. Tribe coding combines a trio of forces: a domain expert, an AI coding tool, and a technical engineer. The domain expert brings context and judgment. They know what problem actually matters and what “good enough” means in the real world. The AI accelerates execution. It translates intent into code, refactors, and enables iteration speeds no human team can match. The technical engineer brings discipline adding structure where it matters. This third role is the difference between something that works and something that lasts. In #tribecoding, engineers do not write more code. They shape how code is produced and validated. They introduce practices: pattern usage, test-driven development, eval frameworks, architectural boundaries, data validation, and security assumptions. Prompting is not the real skill here. The real skill is decomposing systems, defining contracts, constraining model behavior, and knowing when the AI is confidently wrong. It includes automated checks, observability, and feedback loops. In practice, tribe coding looks different from traditional teams. Engineers intervene selectively, reviewing structure, introducing tests, or reshaping the approach. Controlled, but fast progress. At Cognida.ai enterprise software is not built by lone programmers or by AI alone. It is built by tribes that combine domain insight, #AI acceleration, and technical rigor into a single workflow. #PracticalAI

One of the biggest mistakes in the “vibe coding will reduce engineering demand” narrative is a bad assumption. It assumes the amount of software the world needs is constant. It isn’t. Today, enterprises don’t build most of the software they want to build. They build only what they can justify. The constraint is not ideas. The constraint is cost, headcount, timelines, and complexity. Enterprise-grade software is expensive, slow, and resource-heavy, so organisations prioritise a small subset of problems and ignore the rest. That constraint is now breaking. Vibe coding and AI don’t just compress time and cost. They change the economics of what is worth building. When software becomes cheaper and faster to create, the backlog doesn’t shrink. It explodes. Internal tools, workflow automation, decision systems, experimentation layers, niche products, long-tail use cases — these were never “not needed.” They were just not viable. So no, we won’t see a meaningful reduction in software being built. We will see a massive increase in it. Yes, fewer engineers may be required to ship a single product. But far more products will exist. Far more code will be written. Far more systems will need to be maintained, governed, secured, and integrated. The future isn’t fewer engineers writing less code. It’s more software everywhere — built by smaller teams, faster cycles, and entirely new assumptions about what is worth building.

The sad reality of vibe coding is that we’re shipping more code while understanding less of it. I keep seeing stories like this: Developers who can move fast with AI, tests pass, PRs check all the boxes. But the moment something breaks in production, they don’t know where to look. Coding is becoming something you do on autopilot, instead of with intent. Instead of debugging, you’re traces go straight into an LLM that commits the fix. No one can explain why it broke or why the fix works, especially when that context is no longer in the context window. And for a whole generation of coders, that’s what debugging looks like. Not because they’re lazy. Because this is how many people are learning to code now. And it changes what “knowing how to code” even means. Before, debugging was where you actually started to understand the system. Now it’s becoming “fix it” or “make it work” you pass in the chat. This is why I keep saying: vibe coding is powerful, but vibe engineering matters. I’m no way against using AI for coding, but use it with intent. Ask questions and let it self document, don’t just press “tab” or “accept”.

“Vibe coding” could create the next shadow estate in enterprises. For years organisations have wrestled with shadow IT — teams adopting tools outside official governance. AI coding assistants are now changing the scale of the issue. With vibe coding, people describe what they want in plain language and AI generates the software. What once required developers can now be created by analysts, operations teams or sales leaders in minutes. The upside is obvious: faster innovation and problems solved at the edge of the organisation. But it may also create something new — a shadow application estate. Instead of unsanctioned tools, businesses could soon have thousands of AI-generated micro-applications: • workflow automations • data utilities • integration scripts • internal dashboards Many will work perfectly well. Most will never pass through architecture governance, security review or lifecycle management. So the challenge for CIOs isn’t stopping vibe coding. It’s building the guardrails for a world where anyone can become a developer. Because the biggest AI shift inside enterprises may not be automation. It may be the quiet arrival of thousands of new software builders across the business.

Notes from the trenches of Reddit and Hacker News: In 2026, a clear consensus has emerged: pure "vibecoding" is a ticking time bomb. - Comprehension/Cognitive Debt: This is the defining term of early 2026 on Hacker News. Unlike classic technical debt (where the code is just bad and needs refactoring), AI-generated code often looks immaculate, and all the tests are green, but no one on the team understands how it works at a fundamental level. When this kind of code breaks in production, fixing it requires a colossal effort because the team lacks a mental model of the system. - The Compression Problem: This phenomenon has been heavily discussed on Reddit in March 2026. AI is excellent at generating the obvious facade (e.g., a login screen or forms), but it "compresses" (i.e., ignores) the invisible business logic—like checking access permissions between user roles. The developer sees that the feature works visually, merges the branch into the main codebase, and a critical vulnerability is baked into the project. - Repository Slop: A 2026 term describing tons of rapidly generated, redundant code. In March, one developer shared a case study: they spent 18 million API tokens (and a massive amount of time) just to clean up the chaos of hardcoded styles and illogical database schemas that AI agents had spawned in their project during the first few weeks of mindless vibecoding. - The Shift to Spec-Driven Development (SDD): To survive, senior engineers are pivoting to strict SDD. The major trend of 2026 is creating files like CLAUDE.md in the root repository, which strictly define architectural contracts and rules that AI agents are forced to read and adhere to during every generation. #ai #llm #vibecoding #problems #sdd

𝗔𝗜 𝘄𝗿𝗶𝘁𝗲𝘀 𝗰𝗼𝗱𝗲 𝗳𝗮𝘀𝘁𝗲𝗿 𝘁𝗵𝗮𝗻 𝘁𝗲𝗮𝗺𝘀 𝗰𝗮𝗻 𝗸𝗲𝗲𝗽 𝘂𝗽 𝘄𝗶𝘁𝗵. Until nobody understands what’s running anymore. That’s vibe coding in a nutshell. It feels like magic - until you have to ship something real. And then the bill comes due. You don’t get one coherent system. You get a patchwork of plausible code that ages badly. AI optimizes for “sounds right”, not “is right”. So you end up with: ✦ hidden coupling that breaks in strange places ✦ “temporary” choices that become permanent architecture ✦ code that compiles cleanly, but can’t be reasoned about Skip that, and decay shows up everywhere: ✦ architecture that can’t absorb new requirements ✦ security boundaries that exist only in someone’s head ✦ deployments held together by ritual, not design ✦ on-call engineers debugging by guesswork at 2 a.m. ✦ “fixes” that create two new incidents next week Anyone who can write a prompt can assemble something that looks like a product now. And that’s the trap. Vibe coding looks clever until it has to scale. Until it’s inside a real enterprise system. Until it touches customer data, dependencies, and production infrastructure. AI is a powerful accelerator. But without constraints, it accelerates entropy. AI doesn’t fix bad engineering. It exposes it faster. 𝗬𝗼𝘂 𝗱𝗼𝗻’𝘁 𝗯𝘂𝗶𝗹𝗱 𝗿𝗲𝗹𝗶𝗮𝗯𝗹𝗲 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 𝗯𝘆 𝗮𝗰𝗰𝗶𝗱𝗲𝗻𝘁. 𝗢𝗿 𝗯𝘆 𝘃𝗶𝗯𝗲. You build them with architecture, fundamentals, and the discipline to say no to shortcuts that feel productive but aren’t. AI won’t save you from technical debt. Fundamentals will. ↓ 𝗜𝗳 𝘁𝗵𝗶𝘀 𝘄𝗮𝘀 𝘂𝘀𝗲𝗳𝘂𝗹, 𝘆𝗼𝘂 𝗺𝗮𝘆 𝗮𝗹𝘀𝗼 𝗲𝗻𝗷𝗼𝘆 𝗺𝘆 𝗳𝗿𝗲𝗲 𝗻𝗲𝘄𝘀𝗹𝗲𝘁𝘁𝗲𝗿: https://lnkd.in/dbf74Y9E