Vibe Coding Got Me to Production. Here's How I'm Learning to Actually Write the Code.

· 7 min read · vibe-coding, ai-engineering, learning, software-engineering, career

I can read and explain code that AI wrote for me, but I can't yet write it from scratch. This post covers what the research says about that gap, the four-rung skill ladder I use to think about it, and the 30-day plan I'm following to close it.

The uncomfortable truth

I've shipped real software with AI writing most of the code. I've worked on many production applications in the corporate world, and on a few of my own. Recently I built an SDK for agent observability for a finance agent. It traces the agent's steps of thinking, checks whether the agent is following the correct steps, tracks whether it performs better against a set of KPIs, and includes evals. It works. I understand how the pieces fit together, and I can read the code and explain what it does. For every system I've built this way, I can walk you through the flow and the architecture.

But if you closed the AI and handed me a blank file, I'd struggle to write the logic line by line. Gradually I've gone from someone who codes to someone who plans things for an agent, more like an architect. That gap is what this blog is about, and what I'm doing about it.

What vibe coding gave me, and what it quietly took

Vibe coding gave me speed and scope. I built things I couldn't have built by hand yet, such as that observability SDK in JavaScript (I had never written a line of JS), and I learned how real systems fit together: routes, data models, state, deployment.

Writing code by hand means making small mistakes, reading the error, and fixing it. That loop is where debugging instincts form. When AI writes the code and fixes the errors, you skip the loop, and you don't notice the missing skill until the AI can't solve a problem for you.

For me, the tell was small edits. I could tweak variable values, styling and boilerplate, but anything that needed new logic went straight back to the AI. On each project I thought about everything from the user's point of view, planned it like a senior engineer, and handed the build to the AI. Later I checked the code. It ran well, but I didn't understand it. Simpler functions were fine, and it has been going on like that for a while.

Is this actually a problem?

Partly, yes. Partly, it's overblown. Here's what the evidence says.

The case that it's a problem. In January 2026, Anthropic published a randomized controlled trial: 52 engineers learned an unfamiliar Python library (Trio), half with AI help and half without. The AI group averaged about 50% on a follow-up quiz versus about 67% for the hand-coders. The biggest gap was debugging. Hand-coders hit more errors, but they fixed them themselves, and that struggle is what built the skill.

Other signals point the same way. An earlier METR study found experienced developers were about 19% slower with AI while believing they were about 20% faster. And a 2026 Stack Overflow survey reportedly found 76% of AI-tool users had shipped code they didn't fully understand at least some of the time.

The case that it's overblown. The Anthropic study measured comprehension right after a short task, on one library, with a small sample. It says little about long-term careers. Crucially, it also found that how people used AI mattered: the high scorers (65% and up) generated code and then asked follow-up questions to understand it. The low scorers (under 40%) delegated generation or debugging entirely. Same tool, very different outcomes.

GitHub's Cassidy Williams put the practical point well: the option to open an editor and write code yourself hasn't gone away. You can still choose to.

My honest read: I don't need to stop using AI. I do need to stop delegating the understanding.

The skill ladder

I think of it as four rungs:

  1. Prompt and ship. Describe what you want, get working code.
  2. Read and explain. Look at code and say what it does and why.
  3. Debug and edit without AI. Fix a broken thing with only docs and your own head.
  4. Write from scratch. Blank file, working logic.

Vibe coding gets you to rung 2 quickly, and that's a real, valuable skill. The gap is rung 3, which is exactly where the research says AI users lose the most. So rung 3 is where I'm training first. Rung 4 grows out of it.

Four rungs left to right: prompt and ship, read and explain, debug and edit without AI, write from scratch. Rung 3 is highlighted as the gap.
Figure 1. The four rungs. Vibe coding covers rungs 1 and 2 quickly; rung 3 is the gap to close first.

A quick test before you trust your own understanding

"I understand it" is easy to overestimate. Try this on code AI wrote for you:

  • Can you explain why each part exists, not just what it does?
  • Can you predict what happens if you change one line?
  • Can you fix a deliberately introduced bug with the AI closed?

If any answer is no, you understand the shape, not the code. I failed the third one the first time I tried it.

What I'm doing about it

A loop, repeated on small pieces:

  1. Generate. Let AI draft one function, endpoint or component.
  2. Interrogate. Ask why, line by line. Explain it back in my own words.
  3. Delete and rewrite. Close the AI. Rewrite it from memory, using only docs and Google.
  4. Diff and log. Compare with the original. Write down what I missed.

This mirrors the high-scoring pattern from the study: generation followed by comprehension, not delegation.

A four-step clockwise loop: generate, interrogate, delete and rewrite, then diff and log, which leads back to generate.
Figure 2. The practice loop. Step 3 is the one that builds the skill.

A worked example of the loop

Here's the loop on a tiny function. Say the AI gives me a word-frequency counter:

from collections import Counter
import re

def word_freq(text: str) -> dict[str, int]:
    words = re.findall(r"[a-z']+", text.lower())
    return dict(Counter(words))

Interrogate. Why .lower() first? What does the regex keep and what does it drop? What happens with an empty string, or with a word like "don't"?

Delete and rewrite. I close the AI and write it again from memory, with only the docs open. A typical first attempt is a manual loop over a plain dict that forgets punctuation and casing.

Diff and log. I compare the two versions and write one line per miss: Counter exists, a regex beats split(), handle apostrophes. Next week I try a variation, such as top-N words or reading from a file.

This is slower than prompting. That is the point: the slowness is the learning.

Rules I'm holding myself to:

  • Small scope. One function at a time, not a whole app.
  • Debugging by hand first. Try for a set time (say 20 minutes) before asking AI.
  • A public log. I keep my practice code in a public repo so I can't quietly skip it.
  • Real bugs count. When something breaks in a real project, I fix one by hand each week.

A 30-day plan

Here's the plan I'm following. Adjust the numbers to your own level.

Week Focus Exercise Done when
1 Read and predict Take 5 AI-written functions from my own projects and predict the output before running them I predict 4 of 5 correctly
2 Debug by hand Fix real or deliberately planted bugs using only docs, with a 20-minute limit before asking AI I fix 3 bugs without AI
3 Rewrite from memory Run the delete-and-rewrite loop on 5 small functions My rewrites pass the original tests
4 Build small, solo Build one small tool end to end with no AI, only docs and Google It's in the repo, with tests

What I'm not doing

I'm not quitting AI tools, and I'm not hand-writing everything out of pride. For prototypes and boilerplate, AI is the right call. The goal is to be able to supervise it, catch its mistakes, and work when it's wrong, not to prove a point.

Where this leaves me

Shipping with AI made me productive. Rewriting by hand is making me reliable. I think that difference will matter more over the next few years, because when the generated code breaks in production, someone has to understand it.

If you've been vibe coding too, try the three-question test on one file this week. If you can't pass the third question, you've found your rung 3. I'll post an update after the first 30 days with what worked, what didn't, and how my own results changed.

Got a better rung 3 test, or a different way to close the gap? Tell me in the comments.

Sources