Lovable, and the cardboard model problem

The other day I was sitting at the cigar lounge with a buddy of mine. We weren't talking about either of our companies. We were talking about a completely separate idea he'd been kicking around. An app, he said. Something he thought a lot of people would use. He started describing it.

And I started reacting.

I was nodding. Asking questions. Pushing back on a feature. Offering an opinion about the navigation. About fifteen minutes into the conversation, it hit me what was actually happening.

I was reacting to an app that didn't exist. And worse, the app I was reacting to in my head almost certainly wasn't the app he was describing in his.

Two guys, one table, two completely different apps. Both of us thought we were talking about the same thing.

The problem with ideas

Here's what I know about new ideas. The hard part with an idea isn't whether it's good. The hard part is that it lives in exactly one head, which is the head of the person who came up with it. Everyone else who hears about it is reacting to their own version of what they thought they heard.

You can write a document. You can build a slide deck. You can sketch it on a napkin. The other person nods. They ask good questions. They say things like "yeah, I'd use that." And you walk away thinking you've had a real conversation about the idea.

You haven't. You've had two different conversations at the same table. You were both polite about it.

The gap between what I'm describing and what you're hearing is the most expensive gap in any work that starts with an idea. For most of our working lives, the only way to close that gap was to actually build the thing. Which meant hiring a developer. Which meant time. Which meant money. Which meant the idea had to be far enough along to justify the investment before anyone else could actually see it.

So most ideas never got that far. They lived and died inside one head.

Why cardboard models exist

Think about what an architect does when they want a client to react to a design.

The architect can show up with blueprints. Beautiful drawings, technically precise, everything labeled. The client looks at the blueprints and says something polite. Then they go home and lie awake worrying about whether the loft is going to feel claustrophobic, because they couldn't actually picture it.

That's why architects also build cardboard models. Little scale versions of the house, with tiny windows cut out, made of cardboard and glue. The client looks at the model and the conversation changes completely. Suddenly they have opinions. They point at the loft and ask about the ceiling height, because now they can see it. They notice that the kitchen has no clear path to the dining room. They ask whether the staircase is going to feel like an entrance or a wall.

Nobody is confused by the cardboard. Nobody looks at the model and worries their actual house is going to be tiny, or made of cardboard, or have an X-Acto knife edge along the roofline. The model isn't pretending to be the house. It's a thinking tool for talking about the house.

That's what a prototype is. It's a cardboard model. It's not the product. Everyone in the room knows it's not the product. But it gives you something to point at, and the moment you have something to point at, you can finally have the conversation you were trying to have all along.

I've used prototypes this way my entire career. Not as a path to a real product. As a way to think out loud with other people.

What changed

The reason most of us don't build prototypes for our ideas isn't that we don't see the value. We do. The reason is that we can't.

Most people who have ideas aren't developers. And the people who are developers are busy. Building a cardboard model used to mean hiring someone, scoping the work, paying for it, waiting a week, and then iterating from there. By the time you had something to point at, the idea was already six weeks old and you'd had to defend it three times to keep the project alive.

So we settled. We described our ideas in words. We drew them on whiteboards. We accepted that the other person was probably imagining something different, because the alternative was to give up on the conversation entirely.

That's what I went home and tried a different approach.

I sat down. I wrote three paragraphs describing the app my buddy and I had been kicking around. Not specs. Not even a list of features. Three paragraphs of plain English about what the thing was and who would use it. I pasted those three paragraphs into a tool called Lovable.

By the time I was done with my first Coke Zero, the app existed (I drink quickly).

I want to be careful about how I describe what came back, because the wrong words will set the wrong expectation. What Lovable gave me wasn't a finished product. It wasn't anything I'd put in front of a paying customer.

It was a working web app that did the thing I'd described. You could open it on your phone. You could click around. You could see what the screens looked like and what the flows felt like. It was a cardboard model that you could actually use.

The conversation Aaron and I could have would never be like that first one. We wouldn't be arguing about the idea in the abstract anymore. We could talk about that screen, right there. We would be pointing at the same thing.

The prototype didn't answer questions for us. But it opened the door for great questions and a way to talk about it in sync.

What Lovable actually is

Lovable is one of a handful of tools that have shown up in the last couple of years that let you describe an app and get a working version of it back. You don't have to write code. You don't have to know what a framework is. You describe what you want, in plain English, and a working app appears. When you want to change something, you tell it. The app updates.

There are others in this category. You may have heard of Replit or Bolt or v0. They're all swimming in the same pond. I picked Lovable for this build because it's the one I've had the most success with for the kind of prototyping I do, but the bigger story isn't which tool. The bigger story is that this category exists. The cost of building a cardboard model just dropped to roughly zero, and the time dropped to roughly an afternoon.

That changes who can have conversations about ideas.

If you're not a developer, you can now build a prototype of the thing you've been describing for years. Not the real product. The cardboard model. The thing you point at so the other person stops imagining their version and starts reacting to yours. That alone is worth the price of admission, and the price of admission is basically free.

If you are a developer, you can stop spending two weeks of your team's time on every "what if we built…" conversation. You can answer those conversations in an afternoon. Most of the answers will be no, and that's the point; the prototype lets you find out cheaply.

I'm going to walk you through exactly what this looks like in the next post (Thursday). I'll walk you through the result of my conversation with my buddy (volunteer coordination for a little league). I'm going to show you what it looks like, what I asked Lovable to build, and what it did under the hood while I wasn't paying attention.

After that, I'm going to tell you what would have to be true for that prototype to actually run a real season for a real league. There's an important gap between a working prototype and a product you'd let real volunteers depend on.

But before any of that, the thing I want you to take away from this post is simple.

If you've ever tried to explain an idea and watched the other person nod while clearly imagining something different, you know the problem I'm describing. The cardboard model used to be the privilege of people who could afford to commission one. It isn't anymore.

What would you build, if all it took was three paragraphs?