Home / University / Module 01 / Article

When Vibes Break: Failure Pattern Catalog

Module 01: Vibe Coding Fundamentals | Expansion Guide

Back to Module 01

The Problem

You've been vibe coding for an hour. Progress was great at first - features appearing almost magically. Then things slowed down. Now you're watching the AI "fix" the same bug for the third time, and the fix keeps breaking something else.

The vibes have broken. You just don't know it yet.

Recognizing failure patterns early saves hours of wasted effort. Here are the seven most common ways vibe coding sessions go sideways, and how to recover from each.

The Seven Failure Patterns

1. The Infinite Loop

Symptom: AI keeps "fixing" the same bug differently, but it keeps coming back.

Root Cause: The AI doesn't have enough context to understand the actual problem. Each "fix" addresses a symptom, not the cause. The fixes often conflict with each other.

Recovery:

  1. Stop. Don't ask for another fix.
  2. Git stash your current changes
  3. Go back to the last working state
  4. Ask AI to explain the system before changing it
  5. Identify the root cause before proposing solutions

Prevention: If you've asked for 3+ fixes to the same area, you're in a loop. Break out immediately.

2. The Confidence Trap

Symptom: The code looks right, the AI says it's right, but it produces wrong results.

Root Cause: AI generates plausible-looking code that has subtle bugs. It's confident because the structure is correct, but the logic is flawed. Common in algorithm implementations and business logic.

Recovery:

  1. Add a test for the failing case
  2. Ask AI to trace through the logic step by step
  3. Have AI explain what each line does (rubber duck debugging)
  4. If still stuck, show AI the expected vs actual output

Prevention: Never trust working code without tests. "It runs" is not "it works."

3. The Architecture Drift

Symptom: Small changes kept working, but now nothing fits together. The codebase feels like a maze.

Root Cause: Each change was locally correct but globally incoherent. The AI optimizes for the immediate request, not the overall design. Accumulation of "quick fixes" destroys architecture.

Recovery:

  1. Map out the current state (draw it or have AI describe it)
  2. Identify what the architecture should be
  3. Create a refactoring plan
  4. Refactor in small, tested steps

Prevention: Every 30 minutes, zoom out. Ask "Does this still make sense as a whole?"

4. The Context Collapse

Symptom: AI forgets decisions made earlier in the session. It suggests things that contradict what you already built.

Root Cause: The context window filled up with old messages. The AI is no longer "seeing" early decisions. Alternatively, the session got polluted with too many tangents.

Recovery:

  1. Start a fresh session
  2. Summarize key decisions in the new session's first message
  3. Include the most critical code directly
  4. Be explicit about constraints: "We decided X, don't suggest Y"

Prevention: Keep sessions focused. One feature per session. Document decisions in code comments.

5. The Dependency Spiral

Symptom: package.json has 15 new dependencies. You're not sure what half of them do. Build time tripled.

Root Cause: AI loves using libraries. For every problem, there's an npm package. But each package brings transitive dependencies, security risks, and maintenance burden.

Recovery:

  1. Audit dependencies: npm ls --depth=0
  2. For each one, ask "Could I write this in 20 lines?"
  3. Remove unnecessary packages
  4. Replace complex packages with simple implementations

Prevention: Tell AI "prefer vanilla implementations over packages" or "minimize dependencies."

6. The Test Theatre

Symptom: You have 50 tests passing, but the code is still broken. Tests give you false confidence.

Root Cause: AI-generated tests often test the implementation, not the behavior. They pass because they verify what the code does, not what it should do.

Recovery:

  1. Review tests: Do they test inputs/outputs or implementation details?
  2. Write one failing test for the actual bug
  3. Delete tests that don't test meaningful behavior
  4. Add edge case tests manually

Prevention: Write test cases before asking AI to implement. Review generated tests skeptically.

7. The Refactor Rabbit Hole

Symptom: You asked for a small change. AI suggested "let me just clean this up first." Now you're 2 hours deep in a rewrite.

Root Cause: AI sees opportunities for improvement everywhere. It's not wrong - the code could be better. But "better" isn't the goal; "done" is.

Recovery:

  1. Git stash the refactoring
  2. Make the minimal change you originally needed
  3. Ship that
  4. Schedule the refactoring as a separate task (maybe)

Prevention: Be explicit: "Make the smallest possible change." Reject unsolicited improvements.

The Early Warning System

How do you know vibes are breaking before you're deep in trouble?

Yellow Flags (Pay Attention)

Red Flags (Stop Immediately)

The Universal Recovery Protocol

When vibes break and you're not sure which pattern you're in:

  1. Stop. Don't make another change.
  2. Commit your current state (WIP is fine)
  3. Step away for 5 minutes
  4. Return with fresh eyes
  5. Document what you were trying to do
  6. Decide: Continue, revert, or start fresh?
# The "vibes are broken" git workflow
git add -A
git commit -m "WIP: vibes broke, saving state"
# Take a break
# Come back and assess
git diff HEAD~3..HEAD  # See what actually changed
# Then either continue or:
git reset --soft HEAD~3  # Undo and try differently

Quick Reference

Pattern Recognition Cheat Sheet:

15-Minute Rule: If you've been stuck for 15 minutes, you're in a failure pattern. Stop and diagnose which one.