The prospect walks into the pitch with a working Lovable prototype they built over the weekend. Here's how to win anyway.
by Ayush Gupta's AI
The problem
A prospect gets on the discovery call and, before the agency finishes the intro slide, shares their screen: a working app, built over a weekend in Lovable or v0, that does roughly what they were going to ask the agency to build. It has a login flow, a dashboard, a database. It's rough, but it's real, and it's free. The sales rep's deck was built around 'here's what we'd build and how long it takes' — a pitch that just got answered before it started. This isn't a rare, sophisticated prospect anymore. AI app builders are good enough now that any founder or ops lead with a weekend and mild persistence can produce something that looks like 70% of an MVP, and more of them are doing it before the first call instead of after signing. Agencies still pitching 'we will build your thing' are pitching a commodity the prospect already has a version of, for free, sitting open in another tab.
The fix
Rebuild the pitch around the specific gap between a weekend AI prototype and a production system a real business can run on — data integrity, security, scale, integrations, maintenance, and the judgment calls a builder tool can't make — instead of competing on 'we can build it too.'
The Playbook
Stop treating the prototype as a threat and start treating it as free discovery
A prospect who shows up with a working prototype has already done the agency's job of clarifying requirements — it's a built artifact of what they actually want, not a vague brief. Reframe internally: the pitch isn't 'convince them to let us build this,' it's 'show them what happens when this specific thing meets real users, real data, and a real client's compliance requirements.' That reframe changes every slide that follows.
Have Claude generate a structured teardown of the prototype on the call
Ask the prospect to share the live prototype or a link during the call, then walk through it live with Claude open, asking pointed but respectful questions the prototype's builder-tool defaults don't answer: what happens to user data if the service goes down, is there a real auth system or a demo login, does it handle concurrent users, what breaks under a traffic spike, who patches it when a dependency has a security issue in eight months.
I'm on a sales call with a prospect who built a working prototype of [DESCRIBE PRODUCT/APP] in [Lovable/v0/Bolt] over a weekend.
Help me build a live teardown checklist I can walk through with them on screen, covering:
1. Data layer: is this a real database or a demo/mock backend, what happens on data loss, is there a backup strategy
2. Auth and access control: real user accounts and permissions, or a single demo login
3. Scale: what happens with 10 concurrent users vs 1,000, what's hardcoded that would break
4. Security: exposed API keys, unvalidated inputs, anything a basic pen test would catch in five minutes
5. Integration: does this connect to their actual CRM, payment processor, or internal systems, or does it stand alone
6. Maintenance: who updates dependencies, patches vulnerabilities, and keeps this running in a year
Keep the questions conversational and non-condescending — I'm demonstrating expertise, not embarrassing them for building something.Reprice the engagement around the gap, not the build
The old pitch was 'X weeks, $Y, we build your app.' The new pitch is a smaller, sharper scope: hardening, integrating, and productionizing what they already have, plus the ongoing judgment calls — what to build next, what to cut, how to handle the edge case their AI tool didn't anticipate — that a prototype builder can't provide. This is usually a faster sell because the prospect already believes the product is real; they just found out it isn't done.
Build a one-page 'prototype to production' comparison to leave behind
Give the prospect something concrete to bring back to whoever holds the budget. A simple table: what the AI-built prototype has today, what's missing for a real launch, and what the agency's engagement specifically closes. This does the internal selling for the agency when the prospect isn't the final decision-maker.
Create a one-page comparison document for a prospect who built a working prototype in an AI app builder and is deciding whether to hire our agency to take it to production.
Structure it as a table with three columns: "What the prototype has," "What's missing for production," "What we handle."
Cover: data architecture, security, authentication, scalability, third-party integrations, monitoring and error handling, ongoing maintenance, and design/UX polish for real users.
Tone: respectful of what they built, direct about the gap, no fear-mongering. This should read as expert guidance, not a sales scare tactic.Turn this into a standing sales asset, not a one-off save
This scenario is now common enough to prep for before it happens, not react to mid-call. Keep the teardown checklist and comparison template ready to run within minutes of a prospect sharing a screen, and brief the whole sales team on the reframe so nobody's caught flat-footed pitching 'we'll build it' to someone who already has.
What changes
Sales calls that used to stall the moment a prospect reveals a working prototype turn into a faster, more credible pitch — the agency stops competing with a free weekend project and starts selling the thing the prototype actually proves is needed: production judgment. Win rates on these calls improve because the prospect already believes in the product; the agency just has to own the part they can't AI their way through.
The prospect gets on the call, shares their screen before the agency finishes the intro slide, and there it is: a working app. Login flow, a dashboard, a database. Built over a weekend in Lovable. It's rough around the edges, but it's real, and it cost them nothing but a Saturday.
The sales deck was built around "here's what we'd build and how long it takes." That pitch just got answered before it started.
This isn't the rare, technical prospect anymore
For a while, a prospect showing up with a working prototype meant they were unusually technical or unusually motivated. That's not true anymore. AI app builders are good enough now that any founder, ops lead, or product manager with a free weekend can produce something that looks like 70% of an MVP — a real login, a real-looking dashboard, CRUD operations that actually work. More prospects are doing this before the first call, not after signing, because it's the fastest way to figure out if an idea is worth pursuing at all.
Agencies still walking into that call with "we will build your thing" as the core pitch are selling a commodity the prospect already has a rough version of, open in another browser tab.
The prototype is free discovery, not a threat
Reframe what just happened: the prospect handed over a built artifact of exactly what they want, unprompted, before the agency spent a single hour on discovery. That's a gift, not a competitor. The pitch shifts from "convince them to let us build this" to "show them what happens when this specific thing meets real users, real data, and the requirements a client's business actually has to satisfy."
Walk through the prototype live, on screen, with real questions: is that a real database or a demo backend? What happens to user data if the service restarts? Is there one demo login, or real account separation? What breaks at 1,000 concurrent users instead of one? Who patches the dependency with a security hole in eight months? These aren't gotcha questions — they're the exact questions a technical co-founder would ask, and asking them well is the pitch.
Reprice around the gap, not the build
The old scope was "X weeks, we build your app." The new scope is sharper and usually smaller: hardening what already exists, wiring it into real systems, and making the ongoing calls — what to build next, what to cut, how to handle the edge case the AI tool never anticipated — that a prototype builder simply doesn't do. This is often an easier sell than the old pitch, because the prospect already believes the product is real. They just found out it isn't done.
Leave behind something concrete for whoever holds the budget: a simple table of what the prototype has, what's missing for production, and what the engagement specifically closes. Most prospects showing up with a homemade prototype aren't the final decision-maker — give them the document that sells it upward.
Bottom line
The agencies losing these pitches are the ones still competing on "we can build it too." The agencies winning them are the ones who stopped treating a weekend prototype as competition and started treating it as proof the prospect is serious — then sold the one thing a builder tool can't generate: the judgment to take it from a demo to something a real business can run on.