How much should you build before testing with customers?

Last Monday night, I had a hunch. By Wednesday afternoon, I had a working mobile app — and a lot more clarity.

I didn't build this to launch a company. I built it to test an idea, push myself technically, and see just how far I could get using AI tools I'd been experimenting with. Along the way, I was reminded of one of my core product beliefs:

You don't need a finished product to start learning. You just need something real enough for customers to react to.

Here's how I went from "I wonder if I could…" to a shareable demo in four days — and how this kind of scrappy experimentation is core to how I support teams through Align Product Studio.

The idea: recycling rules, made simple (with AI)

Earlier this year, I completed NYC's Trash Academy, a deep dive into the city's waste systems. What stuck with me most wasn't the infrastructure — it was the human behavior. Most New Yorkers are awful at sorting waste correctly.

DSNY (the NYC sanitation department) has a website that explains how to dispose of almost anything. But it's not exactly intuitive and you have to click through multiple pages to find the information you need. So I had a thought:

What if I could build a mobile app where you snap a photo and it immediately tells you how to appropriately dispose of that item — using image detection and NYC's own rules?

It felt like the perfect bite-sized test:

I gave myself four days — with a soft deadline of Wednesday night, when my MVP Club meets for weekly check-ins.

The build: Claude, Expo, and a lot of curiosity

I've built several web tools so far, but never touched mobile. So I started from zero, using Claude Code to generate and refactor React Native code, and Expo Go to test everything in dev mode on my phone.

Tech stack + tools

By Wednesday night, I had something functional. You could snap a photo, and the app would return instructions on how to dispose of it properly.

But it wasn't robust and it was often inaccurate. The recycling logic was too brittle as I realized I was building the rules independently. So on Thursday morning, I took a step back and asked Claude:

"What if we built NYC's rules into the app directly, rather than attempting to make assumptions after receiving Google Vision's results?"

That shift — combining image recognition with local logic — made the experience far more consistent and much more powerful.

You can see it here: Watch the 2-minute demo

The real goal: fast, tangible validation

I didn't care if this was "launch-ready." I cared about learning:

The answer to all four: yes-ish. And that's the point. Even a rough prototype gives you more signal than a Notion document ever will.

What it reinforced

Working > perfect

Pixel-perfect is irrelevant if the value prop isn't clear. This app wasn't sleek — but it was real.

AI is a legit accelerator

Claude wrote the code. Not always correctly, but enough to bring ideas to life quickly. Knowing how to prompt, debug, and refactor was the real superpower.

Builds spark better conversations than briefs

The moment I shared it, friends started tossing out use cases, edge cases, and new ideas. That's what you want early on.

Speed is a filter

Giving myself four days forced me to scope ruthlessly, prioritize function over finesse, and let go of anything that didn't directly support learning.

Why this matters

This wasn't just a fun side project. It's exactly the kind of work I do through Align Product Studio.

Teams can often get stuck trying to perfect ideas before they test them. I help them do the opposite:

Whether it's a prototype, internal demo, or pilot-ready MVP, I work with founders to go from fuzzy idea to working software that teaches them something useful.

If you're sitting on an idea — try this

Then see where it leads.

And if you want an experienced partner who can help you do it faster and with a strong customer-centric product POV — you know where to find me.