Vibe Coding: Revolution or Risk in Software Development? - SmarterArticles S1E6

Written by Tim Green, narrated by AI. Listen to the full episode here.

🎙️ Season 1, Episode 6 | Duration: 16:19

Vibe coding has entered the developer lexicon with remarkable speed. Coined by Andrej Karpathy in February 2025, the term describes a mode of programming where you accept whatever the AI generates, trusting the output rather than reading every line. It sounds liberating: forget the syntax, focus on the intent, and let the machine handle the details. But what happens when nobody in the room can actually read the code?

This episode examines the tension between AI-assisted productivity and the technical debt it quietly accumulates. When developers treat generated code as a black box, the cracks don't show immediately. They show later, in production incidents, security vulnerabilities, and teams that can no longer explain their own systems.

This episode uses AI voice narration from ElevenLabs Studio.

The Lovable Security Wake-Up Call

The Lovable platform, marketed as an AI-powered app builder for non-developers, suffered a significant security incident that exposed how brittle AI-generated code can be when nobody is checking the output. The platform allowed users to build and deploy applications with natural language prompts, but the generated code contained authentication flaws that left user data exposed.

Trust Without Verification

Lovable's pitch was seductive: describe what you want, and the AI builds it. The problem was that the generated applications had no security review process. Authentication headers were inconsistent, session tokens leaked into client-side code, and API endpoints accepted requests without proper authorization checks. The incident demonstrated that AI-generated code without human oversight is not production-ready code.

The Illusion of Competence

What made Lovable's breach particularly instructive was how normal everything looked on the surface. The applications functioned correctly under typical use. It was only under edge cases and adversarial conditions that the vulnerabilities emerged, highlighting that AI-generated code can appear competent while harbouring fundamental structural weaknesses.

AI That Slows You Down

METR, a research organisation studying AI capabilities, published a study showing that developers using AI assistants actually took 19% longer to complete tasks compared to those working without AI. The finding runs counter to the prevailing narrative that AI makes developers faster.

When Speed Becomes Friction

The METR study found that the time saved by generating code was frequently outweighed by the time spent debugging, verifying, and refactoring that generated code. Developers spent significant effort understanding what the AI had produced, checking for subtle bugs, and integrating unfamiliar patterns into existing codebases. The initial speed gain evaporated once the verification phase began.

The Stack Overflow Trust Gap

Stack Overflow's annual developer survey revealed that trust in AI coding tools remains strikingly low among professional developers. The majority of respondents reported using AI assistants but expressed limited confidence in the output, suggesting that developers are adopting these tools while simultaneously distrusting them, a precarious position for any workflow.

The Hidden Cost of Generated Code

GitClear's analysis of code quality metrics revealed a troubling trend in AI-assisted development: a marked increase in code cloning and a decline in meaningful refactoring.

Cloning Over Crafting

The data showed that AI-assisted development correlates with higher rates of duplicated code blocks. Instead of refactoring shared logic into reusable components, developers working with AI tend to generate new implementations that duplicate existing functionality. This cloned code creates maintenance burdens that compound over time, as each copy must be independently understood, tested, and updated.

Collapsing Refactoring

Perhaps more concerning was the decline in what GitClear terms "collapsing refactoring", the process of simplifying code by consolidating redundant logic. AI-assisted codebases showed significantly less collapsing refactoring, suggesting that teams using AI are adding complexity faster than they are removing it. The codebase grows, but the architecture deteriorates.

A Threat to Junior Developers

A Stanford University study found that junior developer employment has been declining in organisations that heavily adopt AI coding tools, raising questions about the long-term pipeline for software engineering talent.

The Missing Apprenticeship

Junior developers traditionally learn by writing code, making mistakes, and receiving feedback from senior colleagues. AI tools short-circuit this cycle by generating code that juniors then use without fully understanding. The result is a cohort of developers who can produce output but lack the foundational understanding to debug, adapt, or improve that output when the AI gets it wrong.

The Experience Gap Widens

The Stanford study suggests that as AI handles more entry-level coding tasks, the opportunities for junior developers to build real expertise shrink. This creates a paradox: the industry needs experienced developers to oversee AI-generated code, but the pipeline that produces those experienced developers is narrowing precisely because AI is displacing the work that teaches them.