# Prototyping to learn


Someone walks past your desk, or drops a polite message in Slack, and asks: *"Can you send me a daily email?"*

In 2026, you can point a coding agent at a cron job and ship that daily email before lunch. Everybody checks a sprint box, velocity looks great on Friday, and nobody notices you just automated a bad guess instead of solving the actual problem.

Every ten weeks at BrainStation Miami, I walk a new cohort of product managers through that exact conversation. It's also drawn in marker on the whiteboard inside [Home Port](https://andrewdurden.com/):

- *"Can you send me a daily email?"* Why?
- *"So I don't have to check the status page ten times a day."* Why are you checking it ten times a day?
- *"Because I need to know the moment availability changes."* Why?
- *"So I don't miss my window."*

There's the real job. Nobody ever wanted another email newsletter clogging their inbox at 8:00 AM. It was just a tired person's best guess at a solution, and one that can show up twenty-three hours too late when an inventory window opens at 9:05 AM.

On the other half of that whiteboard sits the loop I pair with the 5 Whys: **Listen. Prototype in days. Watch people try it.**

## When first-draft code costs pennies, restraint is the job

Coding agents have pushed the cost of generating a working first draft close to zero. Right at the top of my `SKILL.md` file sits the catch: *"Cloud primitives and coding agents have dropped the cost of generating first-draft code near zero, which makes building and scaling the wrong thing dangerously fast."*

The lazy trap is treating fast code as an excuse to cram ten lukewarm features into every sprint. On the whiteboard card I wrote the counter-rule I try to stick to at work and at home: *"Cheap code isn't a reason to ship more features. It's how we buy back time to find the real problem and earn real delight."*

In class I map that straight onto the Kano curve. Users punish you immediately when basic Must-Haves break, compare you consciously on one or two Performance dimensions like speed or price, and tell their friends about the one unexpected Delighter you nailed. Spinning up realistic prototypes in days buys back weeks you used to burn on speculative slide decks or throwaway production builds, so you can kill three mediocre guesses on Tuesday and pour real craft into the one thing that matters.

And unlike flat Figma click-throughs where testers have to squint and pretend, a working prototype with real inputs exposes friction in thirty seconds flat.

## Three honest exits from discovery

Before my squads staff a multi-sprint roadmap (and inside the `SKILL.md` you can grab off the whiteboard), every discovery pass ends in one of three calls:

1. **Stop or simplify:** Fix the copy, pick a smarter default, or write a plain deterministic rule instead of adding new UI surface area.
2. **Prototype to learn:** Build a live, throwaway spike in days to test the single riskiest human or technical assumption.
3. **Build to earn:** Once real hands prove the loop works and eval gates pass, bring full engineering rigor to scale, auth, caching, latency, and observability.

Before writing a line of prototype code, look at whatever ugly workaround people are cobbling together today in spreadsheets, screenshots, sticky notes, or group chats. If nobody has bothered inventing a workaround yet, urgency is probably lower than the room thinks. And when you hand someone a prototype, do the hardest part of user research: sit on your hands and watch *silently* where they squint, pause, or open another tab to double-check a number.

At Royal Caribbean Group, this stopped being a classroom theory a while ago. I don't want to put a percentage on it, but many people are prototyping first and testing earlier before ever committing to actually building, and half the fun of my week is running workshops, trading Claude skills across desks, and watching PMs and designers realize they can test an idea before their coffee cools.

## Watching prototypes humble my own guesses

Building Home Port itself ran on quick prototypes from the start. When I wondered whether a Miami Vice neon palette might look cool (`"Sure let's try Neon for now?"`), mocking it over a real room frame showed me that it felt cold and gimmicky, so we pivoted to warm dusk timber before lunch. An early horizontal card strip turned into cloth-bound books the same afternoon once we saw how busy small card illustrations looked on a phone.

Even the whiteboard taught me a lesson about my own rules. At one point I mandated `"at most 30 words per side"` to keep the board clean. The next render obeyed me literally and chopped off ten lines that actually explained the diagram, including both headings. Soon after I was eating my words: `"relax the word count, don't remove other things"`. Seeing the rule rendered killed a bad constraint faster than any debate.

Our wedding camera ran the exact same way, except the event only happened once, so the five-day prototype *became* the production app. Getting an end-to-end camera into close friends' hands five days before dinner reshaped it every twenty-four hours:

Friends hesitated for half a second at a button labeled `"Next frame"` because it sounded like advancing a slideshow rather than taking another picture; the next build renamed it `"Take another"`. Nobody knew what a `"roll code"` meant, so that phrase vanished everywhere except the screen for switching phones, where it just says `"your code"`. When I couldn't tell whether fourteen live film previews would read cleaner in two columns or three, we captured both across four phone sizes and picked three-across in two minutes.

## Spike what can sink you, and walk away cleanly

If you aren't sure what to prototype first, pick whatever assumption can sink the whole project. On `CrashCalc`, that meant spending a day proving a single Kotlin math function returned the exact same drag factor (`0.5333`) across Android, iOS, and the JVM before building a single screen. On `Messina OS`, touching a physical living-room TV is painfully slow, so we built a browser simulator with a toggleable "chaos hub" to rehearse dropped Wi-Fi at sixty frames a second on a laptop first.

A prototype starts the conversation with engineering; it never replaces real production architecture. And just as valuable, cheap building makes it painless to let go when the ground shifts underneath you.

In late 2025 I built `ProductPeople` so PMs could stress-test product bets against interview-grounded customer personas. Peers in other industries piloted it. Then in early 2026, frontier AI platforms shipped native project memory right inside the tools PMs already had open all day, and a standalone wrapper stopped solving a real problem. I wound it down in March 2026 with zero regrets and carried forward the parts that actually mattered: written specs before code, trace-grounded evals, and keeping ego out of sunk lines of software.
