Developers don’t trust AI. A recent report from UC San Diego and Cornell titled “Professional Software Developers Don’t Vibe, They Control” demonstrates that developers still don’t trust AI to code for them. The study analyzed AI code assistant usage patterns across hundreds of enterprise developers and revealed how the best developers leverage context to improve quality.
The difference between vibe coding and useful AI output? How you structure the information you give it, how the outputs are reviewed, and the amount of technical debt you incur throughout the process.
Abstraction Level Determines Output Quality
When users ask AI to “create a content generation app” without architectural guidance, it will build something. Will it be functional? Maybe. Will it lack security protocols, error handling, and the architectural coherence that experienced engineers build automatically. Probably.
Ox Security’s “Army of Juniors” report analyzing 300 open-source projects found that AI-generated code is “highly functional but systematically lacking in architectural judgment.” The tool can write code that runs. It struggles to write code that scales, maintains, and secures.
AI coding assistants perform well when you provide prescriptive, orderly structured information. You’re not just providing information. You’re constraining the solution space to areas where AI can operate effectively.
The level of abstraction matters because AI processes smaller, structured context windows more effectively than broad conceptual requests. That means instead of telling it the functionality you want it to build or even the service you want it to use, developers should link the documentation—copy-paste the exact sections of documentation into the prompt for even better control. When working with large ecosystems of code, define explicit directory structures. Include database schemas with specific field names and relationships. Don’t blindly trust the AI will understand the context.
Teams that provide highly structured prompts with explicit documentation and high context value achieve significantly greater success.
Vibe Coding Creates Exponential Technical Debt
OpenAI founding member Andrej Karpathy coined the term “vibe coding” in February 2025 to describe developers using natural language prompts to let AI write, refine, and debug code without structured oversight. The problem with vibe coding isn’t the initial output. It’s what happens five to ten steps later.
Developers point AI at code that needs fixing. It fixes that code. But it also changes files in another directory or template that’s not being looked at. Meanwhile users keep building. Several iterations later, they realize AI has been destroying other parts of the application while they’re focused on one feature somewhere else.
GitClear’s analysis of 211 million changed lines of code from 2020 to 2024 found that code duplication is up 4x with AI assistance. While the vibe might feel nice as everything moves fast initially. The cleanup phase might take 5-10 times longer than the initial build. For non-technical users, cleanup often becomes impossible without professional human intervention. The big lesson everyone learned in 2025 is that technical debt from AI systems compounds exponentially rather than linearly accumulation.
As Dan Cripe wrote in his article, about the conversation the world is having about the death of software in favor of LLMs, “The LLM-native startups crushing it with 2-person teams? They don’t exist. The production systems running on autonomous agents? Few, far between, and running tasks that fall in the LLM sweet spot. The people claiming this is possible right now are either building personal productivity tools (fine, but not enterprise SaaS), running demos that haven’t hit production, or not being honest about how much human intervention is happening.”
Security Vulnerabilities Increase At Scale
More than technical debt, research has proven AI code is generally not secure. Veracode’s 2025 analysis, “GenAI Code Security Report,” found that 45% of AI-generated code contains security flaws. This analysis reflects similar findings from a 2024 report from The Georgetown Center for Security and Emerging Technology that confirmed that AI code generation models “frequently output insecure code.”
These aren’t edge cases. They’re systematic gaps in how AI approaches production-grade development. When you provide AI with general prompts, it optimizes for functionality, not security. It builds what works, not what’s safe. Senior engineers catch these issues immediately because they’ve internalized security principles through years of production experience.
AI Best for Prototyping, Not Production
AI coding tools excel at creative ideation and rapid prototyping. They accelerate the exploratory phase of development where you’re testing concepts and validating approaches. But prototypes and production systems require different standards.
Production code needs comprehensive error handling. It requires input validation, authentication checks, and graceful degradation when dependencies fail. It must handle edge cases, manage state consistently, and maintain performance under load.
AI generates code that works in experimental conditions. Experienced engineers write code that works when conditions aren’t ideal.
Analysis shows that AI tools dramatically widen the velocity gap between low-debt and high-debt coding environments. Companies with clean, well-architected codebases see major productivity gains from AI. Those with legacy systems struggle to adopt AI tools effectively because AI performs poorly in environments with subtle control flow, long-range dependencies, and unexpected patterns.
The Strategic Approach: AI as Junior Developer
The most effective development teams treat AI as a junior developer requiring senior oversight. It’s useful for scaffolding and iteration speed. It’s never trusted with final implementation decisions.
This mental model creates the right expectations. You wouldn’t hand a junior developer a vague requirement and expect production-ready code. You provide structure, review output carefully, and correct architectural decisions before they compound or put into production. The same principles apply to AI.
Give it explicit context. Review every suggestion. Catch security gaps before they reach production. Use it to accelerate creative phases while maintaining human-enforced quality gates.
Organizations investing in “AI + engineer” collaboration frameworks outperform those attempting full automation or rejecting AI tools entirely. The future of software development combines AI-powered velocity in creative phases with human expertise in production deployment.
The tools amplify engineering capacity. They don’t replace judgement.
