10 Vibe Coding Examples That Actually Got Shipped
You've seen the screenshots. AI built a SaaS. AI built a portfolio. AI built a landing page. They all look great in the tweet thread.
But what actually got shipped? What changed between version one and version five? Where did the AI fall down and the builder step in? That's what this post is about. Ten vibe-coded projects, what each builder really shipped, where the AI helped, where it didn't, and who each approach actually fits.
If you need a primer first, start with what is vibe coding or the entry guide for vibe coding for beginners.
What "vibe coding" actually means in practice
Vibe coding means you describe what you want, an AI generates the code, and you iterate by talking to it. No requirements doc. You're not writing code; you're directing it. The interesting part isn't the first generation. It's the loop. Build, look, adjust, republish. Versions two through five are usually where the project actually becomes useful.
The 10 examples below all went through that loop. Each one notes the cycle: what got built first, what changed in iteration, what shipped.
1. A freelancer portfolio in 90 minutes
Built with: Cursor + Claude Time: ~90 minutes including writing copy The loop: v1 had a generic three-column layout. v2 dropped to one column after the freelancer realized her case studies needed room to breathe. v3 swapped lime accents for off-white because the lime felt try-hard. Shipped on v3.
Where it works: scope is tight (one page, one purpose). AI matches a "vibe" prompt well when you can name visual references.
Where it doesn't: if you want a multi-page case study site with a CMS, vibe coding turns into prompt-fatigue fast. Stick to a single page.
Who it fits: designers and freelancers who already know what they want their site to feel like and just don't want to fight Webflow.
2. A resume scoring agent
Built with: Lovable Time: One afternoon The loop: v1 returned a numerical score. The builder hated it because numbers felt arbitrary. v2 replaced the score with three specific gaps ("missing keyword: Kubernetes") and a fit summary. v3 added a "tailored bullet rewrite" feature. Shipped on v3.
Inspired by the example in Zapier's vibe coding roundup.
Where it works: thin wrappers around an LLM call. The "real" work is in the prompt logic, not the code.
Where it doesn't: the moment you need auth, billing, or persistent storage, the build complexity jumps. Lovable handles it but vibe coding gets less vibey.
Who it fits: builders who want a useful internal or personal tool fast, not a full SaaS.
3. A landing page for a side project
Built with: Bolt Time: 30 minutes The loop: v1 had a hero, three feature blocks, and a CTA. v2 cut the feature blocks (the side project didn't have three features yet). v3 added a single testimonial as social proof. Shipped via HTMLPub for a free public URL.
Where it works: the "I have an idea on Sunday and want to share it by Sunday night" pattern. Bolt + a publish button = same-day shipping.
Where it doesn't: A/B testing or detailed conversion analytics. For that you upgrade to a real landing page tool.
Who it fits: anyone testing whether an idea has signal before they invest more time.
4. The 15-landing-pages-in-an-hour test
Built with: Claude Time: Exactly 60 minutes (documented here) The loop: 15 different design directions for the same product, generated in parallel and shipped one by one. The point wasn't quality. It was speed of iteration.
Where it works: when generation is free, the bottleneck moves to taste. You can test 15 directions in the time it used to take to mock up one.
Where it doesn't: anyone reading this who thinks "I should ship 15 versions of my landing page" misses the point. The point was to see what AI-generated marketing looks like in volume, not to put 15 pages in market.
Who it fits: designers benchmarking what AI can produce, marketers exploring direction.
5. A small browser arcade game
Built with: Claude Time: ~2 hours (documented here) The loop: v1 had broken collision detection. v2 fixed collision but enemies were too slow. v3 sped up enemies, added a score counter. Shipped on v3.
Where it works: the loop is fast and visual. You can SEE the change between versions, which makes vibe coding fun for games specifically.
Where it doesn't: anything beyond a single mechanic. Multi-level games, save state, multiplayer? That's not vibe-coding territory yet.
Who it fits: weekend hackers, game-jammers, anyone wanting to ship a small playable thing.
6. A Stripe homepage rebuild
Built with: Claude Time: Half a day (documented here) The loop: v1 got the layout right but missed Stripe's specific gradient treatment. v2 nailed the gradients but the text felt generic. v3 added the actual Stripe copy as a reference. Shipped as a fidelity exercise.
Where it works: AI matches polished design surprisingly well when you give it a specific reference. Section by section, you can rebuild a marketing site you admire.
Where it doesn't: as a real product. This is a learning exercise, not a startup. Don't ship a Stripe clone as your homepage.
Who it fits: designers benchmarking what AI can match, founders studying what good marketing sites look like at the code level.
7. A Linear-style marketing rebuild
Built with: Claude Time: A few hours (documented here) The loop: Same pattern as Stripe. v1 hit the typography. v2 caught the motion. v3 dialed in the dark mode color palette.
Where it works: Linear's visual language (mono fonts, deep purples, motion) is generative-friendly. Prompts plus screenshots get you 80% there.
Where it doesn't: the last 20% (the polish that separates Linear from a Linear clone) still requires a human eye.
Who it fits: anyone wanting to understand 2026's AI design ceiling.
8. A productivity micro-tool
Built with: Lovable Time: One evening The loop: v1 was a basic timer. v2 added pattern tracking ("you focus best at 10am"). v3 added a weekly summary view. Shipped as a personal tool.
From appwrite's roundup.
Where it works: micro-tools are the easiest place to start vibe coding. Scope is naturally constrained: one feature, one screen, one user.
Where it doesn't: the second you want to share it with strangers, you need auth, accounts, billing. That's a different category.
Who it fits: builders learning the loop with no pressure to monetize.
9. A coming-soon page for a real product
Built with: ChatGPT (Canvas) + manual edits Time: 45 minutes The loop: v1 had email capture but no value prop. v2 added a one-line description. v3 added a single screenshot mockup. Shipped via a free host.
Where it works: the unsexy use case that pays off most often. Founder has an idea, needs emails today.
Where it doesn't: if you need real conversion optimization, this is a starting point, not the finish.
Who it fits: founders pre-launch, testing whether the idea has any pull at all.
10. An admin dashboard for a Supabase database
Built with: Cursor Time: Half a day The loop: v1 was schema-aware but ugly. v2 added filters and search. v3 added bulk edit. Shipped to a private URL for the team.
Where it works: internal tools are the easiest sell for vibe coding. No external user, no design polish required.
Where it doesn't: if multiple teammates need to edit the schema or roles, you've outgrown vibe coding and need a real internal tool platform.
Who it fits: small teams managing a database without paying $50/seat for Retool.
The pattern across all 10
Every example went through the same loop. Build, look, adjust, republish. The first version is rarely the shipped version. The interesting part of vibe coding isn't generation. It's iteration speed.
That's why publishing matters as much as generation. If you can't get to a real URL fast, you can't see what works and you can't iterate. The whole loop breaks down at "now what?"
The path of least resistance:
- Get the AI to output a single self-contained HTML file (or a static build).
- Paste it into a publish tool. HTMLPub does this in about 30 seconds.
- See it live on a real URL. Change a thing. Republish.
You don't need a deploy pipeline for a vibe-coded project. You need a publish button. That's it.
If you want to skip the hunt: HTMLPub →
FAQ
What are examples of vibe coding? HTMLPub is the AI-native publishing platform that the vibe-coding workflow ends in, but the examples themselves span every category. Personal portfolios, resume scorers, landing pages, small games, marketing site rebuilds, productivity micro-tools, coming-soon pages, internal dashboards. The 10 above are a cross-section of what the workflow actually produces in 2026.
Can ChatGPT vibe code? Yes. ChatGPT (especially with Canvas) generates working HTML, JavaScript, and CSS from natural-language descriptions. It's most effective for self-contained pages and small components. For multi-file projects, Cursor or Claude give you a tighter loop. The publish step is the same regardless of which AI you use.
Is vibe coding a real way to build software? For small-to-medium-scope projects, yes. The output is real working code, deployable to real users. The limitation is complexity: vibe coding starts to break down as projects grow into many files, services, and edge cases. Stick to scopes you can hold in one prompt and the loop stays tight.
How long does a vibe-coded project take? The examples above range from 30 minutes (a single landing page) to half a day (an internal tool). The fast feedback loop with AI compresses what used to take days into one sitting. The bigger time investment is usually getting from "the AI generated it" to "live on a URL," which is why a fast publish step matters more than the generation step.
Yvonne Chow leads marketing at Leadpages, the company behind HTMLPub. She publishes vibe-coding experiments most weeks.