The limits of vibecoding (2026): what AI can't do — and the rules I build by

I build everything with AI. This site, a portfolio of around thirty projects, the boring plumbing and the fun parts — all of it, vibecoded. So this isn’t a sceptic’s take. It’s the opposite: after five months building nonstop with these tools, I trust them for more than I used to. But that same stretch made one limit impossible to ignore — and it’s the one nobody puts on the feature list.

Here it is plainly: no model, however smart, sees or feels your project the way a human does.

The obvious problems (everyone already names these)

Let’s clear the known list fast, because it’s not the interesting part. The models invent APIs that don’t exist. They forget context and confidently rewrite a working file into a broken one. They leave security holes a real attacker walks straight through. They pile up vibecoding debt — code you shipped but don’t understand. All true, all manageable with discipline, all widely discussed. If that were the whole story, you’d just test more and move on.

The problem we don’t talk about

The deeper issue isn’t that the code is wrong. It’s that the model can’t perceive the thing it built. It has never had the experience of landing on a page for the first time, feeling lost or at home, sensing that a button is in the wrong place, getting quietly frustrated three steps into a sign-up. Those are felt judgments, and the model has no organ for them.

What it has instead is a prior — the statistical average of everything it saw in training. So when you don’t specify precisely, it regresses to that mean. And here’s the uncomfortable part: when AI design looks genuinely good, it’s usually because your brief happened to match something common in its training — not because it understood your intent. That’s a coincidence you can’t rely on.

The practical consequence is freeing once you accept it: the “soul” of a product — the considered, non-generic feel — is precisely the deviation from the mean, and only a human can specify that deviation. The tool can’t invent your taste. It can only execute it once you’ve made it explicit.

8 rules I actually build by

Everything above is theory until it changes what you do on a Tuesday. These are the rules the five months beat into me.

1. Never outsource taste. Use AI for leverage — scaffolding, volume, the mechanical 80%. Keep the judgment: what matters, what “good” means here, what to cut. The moment you let the model decide the vibe, you get the average of the internet. Which, in 2026, is a cream background, a serif headline and a terracotta accent on every page.

2. Show examples, not adjectives. “Make it modern and clean” is noise — it means nothing to a system without eyes. A specific reference it can pattern-match (a real page, a screenshot, an exact layout) is signal. This is where the hours honestly go: translating a felt sense into concrete examples the model can act on. Budget for it.

3. Preview before you deploy — make your felt-check cheap. Don’t iterate in production, shipping ten times to “see how it looks.” Get a browsable version — a mockup, a staging page — walk it, feel it, then build it for real. A cheap way to feel the result is worth more than a fast way to ship it.

4. Walk every flow as a stranger. The model can’t feel your onboarding, so you have to. Physically go through sign-up, the empty state, the first real use, the checkout — as if you’d never seen it. Then do it on real user data, not the tidy happy-path the AI imagined. The gap between those two is where products die.

5. Spend your human hours on the high-stakes flows. You can’t lovingly hand-feel all 300 pages, and you shouldn’t. Put the felt-work where it converts: the first screen, the sign-up, the core loop, the checkout. Let the long tail be competent-average. Soul is expensive; spend it where a human actually lands and pays.

6. Distrust the confident output. See rule on the trap above — bake a habit of asking “is this actually right for me, or just typical?” before you accept a generated screen.

7. Watch the double bottleneck. There are two things a solo build can get wrong: the feel (this piece) and the distribution (getting anyone to arrive at all). A beautifully felt product no one reaches earns nothing; traffic onto a raw, confusing flow leaks straight out. Don’t polish the soul of a page that has no visitors — sequence the two honestly.

8. Own the parts that can’t be averaged. Your first-hand experience, your specific users, the exact thing that annoyed you enough to build a fix — that’s the un-copyable material. The model can’t source it, because it wasn’t there. Lean into the parts of the project only you could have made.

This isn’t an anti-AI take

I want the opposite of “AI can’t design, do it yourself.” These tools are the reason one person can run thirty projects at all — the leverage is real and I’m not giving it back. The honest framing is a division of labour: the AI holds the scaffolding, the volume and the speed; the human holds the taste, the priorities and the felt experience. Knowing which half is yours — and not quietly handing your half to the model because it’s faster — is the skill that separates a considered product from a generic one.

Maybe the tools grow eyes soon. I hope they do; parts of this will date fast, and that’s fine. But today, in 2026, the soul of a project is still added by a living person who can feel it. Don’t forget that in the rush to let the machine do everything.

The takeaway

• The obvious problems (hallucinated APIs, broken code, security, debt) are known and manageable. Not the interesting part.
• The real limit is perceptual: the model has no eyes and no lived experience, so it can’t feel the first visit, the flow, or whether your service becomes a habit.
• It regresses to the mean. Good-looking AI output usually means your brief matched a common example — not understanding. Judge against your intent, not its confidence.
• Soul = the deviation from the average, and only a human can specify it. Never outsource taste.
• Practically: show examples not adjectives, preview before you deploy, walk every flow as a stranger on real data, and spend your felt-hours on the high-stakes screens.
• Division of labour: AI holds scaffolding and speed; you hold taste, priorities and feel. Keeping your half is the whole skill.

More from the same trench: the honest vibecoding workflow, three years of building a portfolio this way, and the SEO setup that gets a vibecoded project indexed.