Vibe Coding's Last Mile Problem
Why We Don't See Many Production Lovable Apps
Your PM just shipped a working prototype in 48 hours. Your non-technical founder built a PoC that actually impressed investors. The future of software development is here, powered by AI, and everyone can build now.
Except there’s a problem nobody wants to talk about.
After working with multiple teams and talking to friends deep in the trenches, I’ve noticed a pattern. Some call it the ‘vibe coding hangover’. The honeymoon phase is over, and teams are discovering that building an app and shipping an app are two very different beasts.
TL;DR
• Vibe coding democratizes the first 90% of development - tools like Lovable, Replit, and Bolt let non-developers build functional apps
• The last mile is still brutal - deployment, infrastructure, security, and optimization require deep expertise that AI struggles with
• This creates a dangerous gap - working prototypes that can’t become production apps
• The logistics analogy holds - like shipping, the final leg to users is disproportionately complex and expensive
• Solutions exist but require intentionality - know your purpose, align processes, and most importantly, know when to bring in experts
What Is Vibe Coding?
Vibe coding platforms let you describe what you want to build in natural language, and AI generates the code. Think Lovable for full-stack apps, Replit’s AI agents, Bolt for rapid prototyping, and to a lesser extent, Cursor (though it’s built for developers).
Examples are everywhere now. PMs who once wrote PRDs are shipping prototypes. Non-technical founders validate concepts before raising capital. The barrier to entry for software creation has essentially evaporated.
Why Now?
I’ve written before about how AI democratizes access to the median professional. AI makes writing boilerplate super easy. It handles the predictable patterns that make up most code. But here’s the catch: this works best over short time horizons and discrete tasks.
Tasks like simple question answering from a domain expert’s perspective? Perfect for AI. Building a complex, production-ready system? That’s where things get interesting. It’s why Replit has been emphasizing how long its agents can last on a task: they know the challenge isn’t starting, it’s finishing.
The Problems Start Compounding
Eventually, when you’re building something new, you have to start innovating and making contact with the real world - infrastructure, security, performance. A common misconception is that programming is very rote, but the best engineers exercise tremendous creative problem solving. Having “median” code generated by an LLM leads to diminishing returns fast.
Vibe coding can lead to serious security issues because deep understanding of systems matters. You can’t prompt your way around not knowing how authentication actually works.
In teams, the problems multiply:
Non-technical users throw AI-generated code over the wall to engineering
Decades of software development best practices get ignored because they’re invisible: automated testing, version control for understanding changes and enabling rollbacks, code reviews that disseminate knowledge
Nobody wants a 30K line code review, but that’s exactly what vibe coding platforms often produce
Infrastructure issues are particularly brutal for AI. I’ve written about debugging a nightmare deployment with Claude Code.
These problems require systems thinking and a complete mental model. Feedback loops are slow. Setting up a domain name might take hours before you know if it worked. Without a good mental model to debug, you end up in frustrating loops.
The Last Mile Problem
Here’s an old engineering joke: coding is the first 90% of work. Then there’s the other 90%.
In logistics, the final delivery leg from distribution center to doorstep accounts for 40-50% of shipping costs despite being the shortest distance. It’s inefficient due to scattered residential stops, traffic, failed deliveries, and individual address complexities.
In software:
Development to Production = Warehouse to Doorstep
“Works on my machine” = Code runs in ideal conditions but fails in real environments
Disproportionate effort = Last 20% (deployment, debugging, infrastructure) takes 50%+ of total effort
Both reveal the same truth: building the thing is the easy part. Getting it successfully into users’ hands is where the real challenge lies.
Real-World Example
A friend recently built a simple SaaS app using Lovable. The prototype phase was magical - natural language to working app in under three hours. User authentication, a clean dashboard, data visualization, even AI pixie dust on it. It all worked perfectly on his computer. Then came deployment to Railway, one of the most developer-friendly platforms out there.
What should have been simple became a multi-day saga. Environment variables were hardcoded. The SQLite database that worked locally needed PostgreSQL in production, breaking some queries with different syntax. Stripe integration looked perfect but failed on webhook signatures and OAuth redirects.
The killer was performance. What ran instantly locally took 5-10 seconds per page load in production. N+1 query problems everywhere, no pagination, I could go on. Three hours to build, four days to deploy - and this was on Railway, a platform specifically designed to make deployment easy.
How Lovable Is Addressing This
Their recent announcements show they understand the problem:
Lovable Cloud - A managed backend solution. They’re trying to become a Platform-as-a-Service faster than PaaS providers become vibe-coders.
Shopify Integration - Smart move. Shopify is already a well-understood platform with clear constraints. There’s good overlap with the low-code audience. A developer wouldn’t need “text to Shopify” - Shopify is already easy enough.
Imagi/OpenAI Partnership - Bringing Lovable to schools. Education was Replit’s initial audience too. Different use case than professional development.
From the Trenches
I spoke to a friend with FAANG experience who transitioned from professional designer to developer:
“Lovable has super good design sense,” he told me. “But it fails at full backend, production quality code.”
He described needing to correct the AI over and over. The codebase got too big for Lovable’s context window. With Claude Code, you need to direct less since it has codebase access, but you’re still dealing with what I call “a savant with amnesia.”
Niche issues that aren’t well documented are brutal to debug with any AI tool. They need tons of direction. “AI doesn’t know what it doesn’t know, or what you don’t know,” as I put it.
At one point, Claude Code literally told him: “You should contact Supabase support.”
“Read the f***ing docs” prompting has become common. You get stuck in unproductive loops making small edits. “Replit is clunky,” he concluded. “Not meant for professionals.”
Solutions That Actually Work
Be intentional about purpose:
Is this a prototype to align stakeholders? Keep it in Lovable, share via their preview links
A proof of concept for the engineering team? Export the code early, review together
The foundation for a production app? Plan for the handoff from day one
Align processes around purpose:
Work cross-functionally early and often. Have engineers review vibe coded apps weekly, not after “completion”
Work with internal and external experts on the last mile - bring in DevOps early, not as firefighters
Document the evolution of ideas so handoffs are smoother. Have AI generate a decision log after each session
Know when to “graduate” from one tool to another. Example: PM uses Lovable for wireframing, Engineering rebuilds core logic in Cursor with proper architecture
Create systematic handoff points:
At 1000 lines of code (coarse but useful measure): Architecture review
Before any external integrations: Security review
Before user data touches the system: Infrastructure planning
When the context window fills up: Time to migrate to professional tools
Budget realistically:
The “last mile” typically takes 2-3x the initial build time
If Lovable got you there in 2 days, budget at least a week for production
Factor in costs for monitoring, error tracking, and actual infrastructure
Remember: an optimized app can be 10x cheaper to run than a naive implementation
Vibe coding doesn’t eliminate the need for expertise, it just moves it.
The Problem Will Get Worse
Building is easier, but building was always the easiest part. As more building occurs, talent and expertise for the last mile gets spread thinner. For example, today there are more developers than ever, but fewer who understand how to work with databases at a deeper level beyond code.
The gap between what can be built and what can be shipped is widening. Vibe coding platforms are incentivized to encourage creation, not necessarily helping users deliver business value. An optimized app runs faster and cheaper. It mitigates catastrophes like security breaches.
Moving Forward
The vibe coding revolution is real and valuable. It’s democratizing software creation in ways we couldn’t imagine three years ago. But let’s be honest about what it is and isn’t.
It’s a powerful tool for exploration, validation, and rapid prototyping. It isn’t a replacement for the deep expertise required to ship production software that scales, performs, and protects user data.
If you’re experiencing this gap between prototype and production, you’re not alone. The tools are evolving, but in the meantime, knowing when and how to bring in expertise for that crucial last mile makes all the difference.
After all, friends don’t let friends ship vibe coded apps... without a plan for the last mile.
Are you stuck in the gap between a working prototype and production-ready app? I help teams navigate the last mile of vibe coded applications. Get in touch if this resonates with your current challenges.
The infrastructue side is ofent overlooked when teams are excited about the feature development phase. In real-world scenarios, deployment pipelines, container orchestration, and monitoring systems demand way more atention than most builders anticipate. Platform engineering practices help bridge this gap by providing reusable abstractions that abstract away complexity.