I Vibe Coded for 6 Months. Here's What I Can't Do.

Six months of AI-generated code taught me to ship fast but left critical gaps. Here's an honest account of what vibe coding does — and doesn't — teach you.

The Setup: Six Months of Shipping Without Understanding

I want to be honest about something. For about six months, I built things almost entirely with AI assistance — Cursor for the coding, Claude for architecture decisions, ChatGPT for debugging. I shipped a SaaS app, a Chrome extension, and two internal tools for clients. All of it worked well enough to get paid. I felt like a genius. Then I took a technical interview. It did not go well.

What I Could Do (The Wins Are Real)

Let's be fair to the vibe coding experience before I criticize it. In six months I learned the rough shape of a full-stack codebase — what files go where, how a React frontend talks to an Express backend, what a database schema looks like. I could read enough code to describe what it did at a high level. I could ship. These aren't nothing. A lot of people spend six months on tutorial hell and have less to show for it. The AI accelerated my exposure to patterns I'd have taken years to encounter.

What I Couldn't Do (The Honest Part)

Here's the list. I couldn't debug without AI help — I didn't understand error messages well enough to form hypotheses. I couldn't write a function from scratch without a prompt. I couldn't explain what was happening in my own codebase at a line-by-line level. I couldn't implement even basic algorithms — the interview question was a sliding window problem and I had no idea what a sliding window was. I couldn't do a code review — I didn't know what 'good code' looked like vs. 'working code.' I couldn't refactor — I was afraid to touch anything because I didn't understand how the pieces connected.

// Interview question: find the max sum of a subarray of size k
// I could not solve this without AI. Here's why:

// What I tried (wrong):
function maxSubarraySum(arr, k) {
  let max = 0;
  for (let i = 0; i < arr.length; i++) {
    let sum = arr.slice(i, i + k).reduce((a, b) => a + b, 0); // O(n*k) — I didn't know this mattered
    max = Math.max(max, sum);
  }
  return max;
}

// Sliding window (what they wanted):
function maxSubarraySum(arr, k) {
  let windowSum = arr.slice(0, k).reduce((a, b) => a + b, 0);
  let max = windowSum;
  for (let i = k; i < arr.length; i++) {
    windowSum += arr[i] - arr[i - k]; // O(1) update — I had no intuition for this
    max = Math.max(max, windowSum);
  }
  return max;
}

The Specific Skills That Were Missing

After some reflection, I identified the exact gaps. First: no mental model for how code executes. I knew what the code looked like but not what happened at runtime — the call stack, memory allocation, async behavior. Second: no data structures intuition. Every data structure problem felt foreign. Third: no understanding of complexity. My code worked but often did unnecessary work I couldn't spot. Fourth: no systematic debugging approach. I relied on 'paste the error into Claude' as my entire debugging methodology. Fifth: no ability to read unfamiliar codebases. I could read code I'd written (barely) but not code written by others.

What I Did About It

I spent three months learning the fundamentals I'd skipped. Data structures, algorithms, debugging methodology, how the browser actually executes JavaScript. It was humbling because I had a working app in production and couldn't explain what a closure was. But it was also faster than learning from scratch — I had context for why these things mattered. The combination of 'shipped something real' plus 'now understand why it works' is actually a solid learning path. The key is not skipping the second part. If you're in the vibe coding phase right now, the AI Engineering Foundations track at Beyond Vibe Code is built exactly for this transition.

The Advice I'd Give My Six-Months-Ago Self

Use AI tools — they're genuinely useful. But for every feature you ship with AI help, spend 30 minutes reading the generated code line by line and asking yourself 'why does this work?' Look up every concept you don't recognize. Keep a learning log. When the AI suggests something, try to predict what it'll suggest before you ask — you'll be surprised how quickly your intuition develops when you're actively building it. Vibe coding without reflection is a treadmill. Vibe coding with deliberate learning is a ramp.