Everyone is vibe coding. Prompting an AI, accepting whatever comes out, shipping it. It works until it doesn't, and when it doesn't, nobody knows why.
I use Claude Code every day. Across planning, implementation, and review. But the way I use it looks nothing like what gets posted on Twitter.
The vibe coding trap
Vibe coding assumes the model knows what you want. It doesn't. It knows what you typed. If you type vague things, you get vague code that passes a surface-level read and breaks on the third edge case.
The output is only as good as the intent behind the prompt. That's not a model problem. That's a thinking problem.
I have watched engineers prompt their way into a working demo in 20 minutes and spend two days debugging production because the model made a reasonable-looking decision that was wrong for their specific data shape. The model was not wrong in any general sense. It was wrong for that context, and nobody checked.
What "with intent" actually means
Before I write a single prompt, I know three things:
- What this piece of code is supposed to do
- What it must not do
- How I will verify it works
That sounds obvious. Most people skip steps two and three entirely.
Step two is where security holes live. It is where the off-by-one errors live. It is where "handle the error case" gets interpreted as "swallow the exception and return None." The model will do something reasonable. Reasonable is not always correct.
Step three is where you find out if you actually understood the problem before you started prompting.
Where I hand it the wheel and where I don't
I use Claude Code to move fast on the parts where speed is the point: boilerplate, repetitive transforms, first drafts of tests, scaffolding a new route that follows an existing pattern. These are low-risk, high-repetition tasks. The model is faster than I am and the output is easy to verify.
I slow down and take over on the parts where judgment matters: data modeling, failure modes, anything that touches auth or external APIs, anything where "plausible" and "correct" are different things.
The model is a force multiplier. Force multipliers amplify what you bring. If you bring nothing, you get nothing, faster.
The review step nobody does
After Claude Code writes something, I read it. Not skim it. Read it line by line. I treat it like code from a junior engineer who is very confident and occasionally wrong in ways that are hard to spot.
I evaluate AI models professionally at Datawise. We run structured benchmarks across dozens of tasks. One thing I have learned from that work: these models are very good at producing output that looks right. Looking right and being right are not the same thing. The gap between them is where bugs live.
Reading the output is not optional. It is the job.
The prompting discipline that actually matters
Vague prompt: "write a function that processes user input"
Specific prompt: "write a Python function that validates and sanitizes a username: ASCII only, 3 to 30 characters, no spaces, raise ValueError with a clear message on failure, no dependencies outside the standard library"
The second prompt gets you something you can ship. The first gets you something you have to rewrite.
The more specific your prompt, the less reviewing you have to do. That is the actual skill. Not knowing which AI tool to use. Not having the right subscription. Writing prompts that leave no room for interpretation.
The actual workflow
Plan in plain language first. Write out what you want and what you do not want before you open Claude Code. Let it draft. Read what comes back. Push back on anything clever. Verify against the original intent. Ship.
That's it. No magic. Just using a powerful tool with the same discipline you'd bring to any other part of the stack.
Vibe coding is a fine way to prototype. It is a bad way to build things that need to keep working.
