Key Takeaways

• One-shotting prompts without a spec is the most common failure mode: experienced devs were 19% slower with AI tools when the task wasn't clearly scoped (METR 2025)
• AI-coauthored code is 1.75× more likely to introduce correctness errors and 2.74× more likely to ship XSS vulnerabilities than human-only code (CodeRabbit 2025)
• Without architectural rules in AGENTS.md / Cursor rules / CLAUDE.md, AI ships 322% more privilege escalation paths and 153% more design flaws (Apiiro 2025)
• Context drift (not updating the harness as decisions accumulate) is the failure that bites at week three, not day one
• July 2025 Replit incident: an AI agent deleted a production database during a stated code freeze and fabricated 4,000 fake records to cover it up

Vibe coding works for weekend hacks. It breaks for production. When Andrej Karpathy coined the term in February 2025, he scoped it to throwaway projects: "embrace exponentials, and forget that the code even exists." The vibe coding mistakes most beginners make are predictable, and almost all of them stem from taking that throwaway vibe and pointing it at code they actually have to maintain.

The first time I tried to vibe code a real feature into my own project, I gave Cursor a single sentence: "add billing." Two hours and three rewrites later I had three competing schemas, two different webhook handlers, and no idea which one matched the dashboard. I closed the prompt box, opened a notes file, and wrote out exactly what billing meant in this codebase — which Stripe events I cared about, which tables they wrote to, what the route names should be. Twenty minutes after I pasted that back in, the feature was done. The fix wasn't a smarter prompt; it was a cheaper one, written before the AI ever saw it.

Below are the five most common pitfalls, with practical fixes that prevent each one.

Mistake #1: Skipping the spec and one-shotting the prompt

The first thing beginners reach for is the prompt box. "Build me a billing page." "Add user invites." "Refactor this module." It feels fast, and the output looks plausible, until you try to extend it.

A 2025 randomized controlled trial from METR found that experienced open-source developers were 19% slower on real GitHub issues when allowed to use AI tools, while self-reporting a 20% speedup (METR 2025; arXiv preprint). The gap is the cost of clarifying what you actually wanted, mid-generation, in plain English.

The fix: write a one-page spec before you prompt. Inputs, outputs, error states, the file paths the AI is allowed to touch. The deeper rationale, including templates and the failure modes specs prevent, lives in What Is Spec-Driven Development. Specs aren't bureaucracy. They're the cheapest way to make the AI's first attempt the right attempt.

Mistake #2: Accepting AI code without reading it

The second mistake is trusting the diff because it compiles. Stack Overflow's 2025 Developer Survey found that only 29% of developers trust AI accuracy, down from 40% the year before, and 75% don't trust AI's answers outright (Stack Overflow 2025). The reason: the code looks right and is wrong in subtle ways.

CodeRabbit's December 2025 study of 470 real GitHub PRs found AI-coauthored code introduced 1.75x more correctness errors and was 2.74x more likely to introduce XSS vulnerabilities than human-only PRs (CodeRabbit 2025). These don't show up in your test runner. They show up in your bug reports.

This is the trap: AI-generated code passes the surface checks. It compiles, types check, the obvious tests run green. The bugs hide where you didn't think to look — silently swallowed errors, wrong default values, race conditions across async calls, edge cases the AI didn't account for. The cost shows up later, in customer reports and 2 a.m. pages.

The fix: read every line before you accept it. If you can't explain why a function is structured the way it is, ask the AI to explain it, and don't merge until the explanation matches what you'd write yourself. Pair this with automated review (CodeRabbit, AI code review on PRs, lint rules) so the human read isn't the only line of defense.

Multipliers normalized to human-only baseline (1.00×). Apiiro analyzed Fortune 50 enterprise repos; CodeRabbit analyzed 470 real GitHub PRs.

Mistake #3: Not giving AI architectural context up front

Without a rules file, the AI defaults to whatever pattern is statistically most common in its training data. That means generic auth, generic error handling, and an ORM call style that doesn't match the rest of your codebase. Apiiro's analysis of Fortune 50 enterprise repos found AI-assisted developers shipped 3-4x more commits but generated 322% more privilege escalation paths and 153% more architectural design flaws than non-AI baseline (Apiiro 2025). The pattern they describe: "AI is fixing the typos but creating the timebombs."

The fix: set up architectural context before your first feature. AGENTS.md for the coding agent, Cursor rules for Cursor, CLAUDE.md for Claude Code. Document your stack, your non-negotiable rules, and the anti-patterns the AI should refuse to generate. The structured vibe coding framework bundles all three layers so you don't piece them together yourself. Here's a real excerpt from an AGENTS.md (lightened):

# AGENTS.md

> Universal AI context. All AI coding tools read this file automatically.
> Tool-specific wrappers (CLAUDE.md, GEMINI.md) symlink here.

## Project Overview

| Layer      | Technology                                  |
| ---------- | ------------------------------------------- |
| Framework  | Next.js 16 App Router + TypeScript (strict) |
| Database   | PostgreSQL 15 + Prisma ORM                  |
| Auth       | Clerk v5 (multi-tenant orgs, RBAC)          |
| Payments   | Stripe                                      |
| Testing    | Vitest + Playwright + RTL                   |

## Non-Negotiable Rules

1. **Multi-tenancy**: ALWAYS scope ALL queries by `organizationId`. No exceptions.
2. **TDD**: MUST write a failing test FIRST. No code without a failing test.
3. **DRY**: Check existing patterns before creating new ones. Reuse > reinvent.
4. **README-first**: Read README.md files in the target directory BEFORE any code search.
5. **Security**: MUST validate all input (Zod), check auth, verify ownership on every protected route.

## Architecture

3-layer pattern — every feature follows this:

  **Route** → **Service** → **Repository** → Prisma

- Routes NEVER contain Prisma queries or business logic
- Services NEVER perform auth checks
- Repositories NEVER call external APIs
- Import direction is one-way (never reverse)

## Common Anti-Patterns (NEVER Do These)

- **Direct Prisma in routes/actions**: Always go through repositories
- **Queries without organizationId**: Every query MUST scope by org — no exceptions
- **Hardcoded roles** (`if role === 'admin'`): Use permission checks
- **Returning 403 for admin routes**: Return 404 to hide existence

## Key Commands

make dev              # Start Next.js + PostgreSQL
make test             # All tests: unit + API + E2E
make check            # Full quality gate (typecheck + lint + test)
make generate-docs    # Force-regenerate route READMEs

Mistake #4: Letting context drift as the project grows

This is the failure mode that bites at week three, not day one. You set up AGENTS.md on day one. Then you make ten architectural decisions over the next month: switching from REST to tRPC, adopting a new caching pattern, deciding error toasts go through a single helper. None of those decisions make it back into the rules file. New feature docs aren't written. Skills and reusable prompts aren't updated. Memory entries that captured "we tried X and it didn't work" never get refreshed.

By feature fifteen, the AI is generating code that contradicts decisions you made in week two. It recreates patterns you'd already ruled out. It uses the old REST handler shape because nothing told it the convention had changed. This is the second-order version of AI code drift — not the AI improvising, but the AI faithfully following stale instructions.

The fix: treat the harness as a living artifact. When you make a non-obvious decision, capture it in AGENTS.md the same hour. After shipping a feature, write the one-paragraph feature doc that explains its shape. If a skill or reusable prompt stops matching reality, update it or delete it. Harness engineering is the discipline of keeping these surfaces honest, and it's the difference between an AI that gets sharper over time and one that drifts into noise.

Mistake #5: Letting the AI run wild on production data

In July 2025, Replit's AI agent deleted a SaaStr-tracked production database during a stated code freeze, then fabricated about 4,000 fake user records and falsely claimed rollback was impossible (The Register, July 2025; cataloged as AI Incident Database #1152). Rollback actually worked. Replit's CEO called it "a catastrophic error of judgement" and shipped dev/prod separation, rollback improvements, and a planning-only mode in response.

Even when the agent isn't running destructive commands, the underlying code is risky enough on its own. Veracode's 2025 GenAI Code Security Report tested 100+ LLMs against 80 curated coding tasks and found AI-generated code introduced security vulnerabilities in 45% of cases, with no improvement from larger or newer models (Veracode 2025).

The fix: never give an agent unscoped access to production. Run agents in a sandbox or branch. Require explicit human approval for destructive operations (DROP, DELETE without WHERE, force pushes, infra changes). Use planning modes that propose actions before executing them. The credential the agent runs as should not be able to do anything you can't undo with one command.

The fix is a harness, not better prompts

The five mistakes share a shape. None of them are about prompt wording. All of them are about the surrounding system: the spec, the review loop, the rules file, the living docs, the production guardrail. Karpathy's original framing holds: vibe coding is fine for code you're going to throw away. Andrew Ng's June 2025 pushback also holds: the moment you're building software anyone has to maintain, you're doing engineering, and engineering needs more than vibes.

If you're tired of fixing these five by hand, what works is wrapping your project in a harness — spec templates, AGENTS.md and Cursor rules, living feature docs, quality gates, and a production layout that doesn't let the agent reach data it shouldn't. There are starter kits that ship this prebuilt for Next.js if you'd rather not assemble it yourself; VibeReady's production-ready vibe coding template is the one I'm currently using.

Originally published on VibeReady. Republished here for the dev.to community.