ProjekinAja. Founder's Playbook Stage 2 · Build The Right Thing Lesson 2.4
● Stage 2 · Lesson 2.4

Prototype Strategies — Before You Write Production Code

Before writing a line of production code, there are three cheaper ways to test whether the solution works — most technical founders skip all of them and pay dearly.

⏱ ~22 min read ⚙ Interactive widget 🧪 Experimentation

🎯 By the end you'll understand

The three canonical pre-production prototype strategies — Wizard-of-Oz, concierge, and smoke test — including specific scripts, success criteria, and failure signals for each. Why running a prototype does not mean deceiving customers, and how to run each method with full transparency. The specific failure mode of technical founders who feel they are "cheating" by not building the full product. And a practical 5-day sprint framework for designing and running a prototype before a single line of production code is written — with daily go/no-go checkpoints and a sunk-cost alarm that fires when scope has crept beyond what a prototype should be.

KEY INSIGHTProduction code is the most expensive way to be wrong

The problem is not that technical founders cannot build. It is that they build to find out what they should have tested with a spreadsheet and a phone call. A Wizard-of-Oz test that takes five days and reveals the solution is wrong costs you five days. The production version of that same wrong solution costs you six months.

You have validated the problem. You have scoped the MVP. Now the technical founder's most dangerous reflex activates: the urge to start building. Not a prototype — the actual system. Scalable infrastructure, clean architecture, the real data pipeline. The reasoning sounds disciplined: "We have validated the problem, we know what to build, why waste time on a fake version?" The answer is that you have not yet validated the solution. The problem being real does not mean your proposed solution is the right mechanism. Between "this hurts badly enough to pay for" and "this specific product solves it in a way we will actually adopt" sits a gap that production code cannot close cheaply.

🔑 The prototype's one job

A prototype is not a demo, a proof of concept, or an early build. A prototype has one job: test whether the proposed solution mechanism works for a real customer in real conditions before you invest in building the production version of that mechanism. The three strategies covered here — Wizard-of-Oz, concierge, and smoke test — differ in what mechanism they test and how. What they share: they all cost an order of magnitude less than production code, they all generate a go/no-go signal, and they all reveal failure modes that interviews and demos cannot surface.

CORE CONCEPTThree cheaper tests before production

Each strategy occupies a different position on the cost/fidelity curve. The right choice depends on what your riskiest assumption actually is — not all assumptions require the same type of test.

Strategy What it tests Rough cost Failure signal Best for
Wizard-of-Oz Whether customers will use the product experience — even before the automated system exists 1–2 weeks of human labor Low usage, wrong workflow, customers reject the UX before automation matters Products where the core value is the output, not the automation mechanism
Concierge Whether the manual delivery of the service creates real value — whether the problem is actually solved when you do it by hand 2–5 weeks founder time Customers use it but do not renew, do not refer, or do not hit a specific outcome metric Services where the value claim involves an outcome (cost reduction, efficiency gain)
Smoke test Whether customers will take a committed action (sign up, pay a deposit, join a waitlist) before the product exists 3–7 days to set up and drive traffic Traffic arrives but no one commits; or traffic does not arrive even with real spend Consumer products, tools, any product where demand is the primary risk
Cost to run → Fidelity of test → Smoke test Wizard- of-Oz Concierge (outcome) Production code → 3 days 2 weeks 6 months
Prototype strategies on the cost/fidelity curve. Production code is not on this chart — it belongs on the right edge, above the dotted line that separates "experiment" from "commitment." A smoke test is cheaper but tests only demand, not delivery. A concierge test is more expensive but tests actual outcome delivery.

HOW IT WORKSWizard-of-Oz — fake the backend, ship the experience

In a Wizard-of-Oz test, the customer sees a complete, polished experience — a UI, a workflow, results — but behind the scenes, a human is doing everything the automated system would do. There is no automation, no ML model running, no production infrastructure. There is a person watching inputs arrive and manually producing outputs. The customer interacts with what feels like a working product. You learn whether the product experience — the workflow, the inputs customers actually provide, the format of outputs they want — works for real users before you build anything automated.

1

Define the specific workflow you are testing

Not "the product." One specific workflow: a customer submits an image of a component → receives a defect classification within 2 minutes → takes a downstream action based on that classification. Write out the exact steps the customer takes. Then write out the exact steps a human (you or a teammate) will take to simulate the automated system. If you cannot describe the manual process precisely, you do not understand the product well enough to build it.

2

Build the minimum frontend — the part the customer touches

This means a real interface — not a mockup, not a Figma link. A real form, a real upload mechanism, a real results display. The customer needs to be able to complete the actual workflow. The interface can be rough; the friction of using it is itself data. For B2B hardware products like Forge, this might be as simple as a web form that emails you a camera image and a slot where you post the classification result. Use Webflow, Glide, a Google Form feeding a Sheet — whatever takes hours, not weeks, to stand up.

3

Run the simulation for 3–7 customer interactions

You are not looking for statistical significance. You are looking for the failure modes that interviews cannot surface: the customer who does not understand what to input, the workflow step that produces confusion, the output format that creates more work instead of less, the case where your model would have been wrong and the customer would have acted on a bad classification. These are learnable only through real interaction. Three to seven sessions will surface the structural problems. If you hit ten sessions with no structural issues, you have a go signal.

4

Success criteria and failure signals

Go signal: The customer completes the workflow without needing to be guided, uses the output to make a real decision, and when asked afterwards describes the experience as "this would be useful for us." Failure signal: The customer cannot figure out what to submit without help; the output format creates confusion or requires manual translation; the customer uses the output but does not act on it; or the latency of 2 minutes (which you can actually deliver in production) is unacceptable in practice and the customer requires real-time results. Any of these failures means the product mechanism needs redesign before a line of production code is written.

💡 The script for a Wizard-of-Oz session

Opening: "We are testing an early version of the inspection assistant. It is not fully automated yet — there are some manual steps involved on our end, which is why results take a few minutes. We want to understand whether this workflow fits how you actually operate, not whether the automation is fast enough." Then step back and observe. Do not guide. Do not explain what to do next. Watch where they get stuck. Where they get stuck is where your product breaks.

HOW IT WORKSConcierge — you are the product, manually

A concierge test is different from a Wizard-of-Oz in a fundamental way: in a concierge test, the customer knows you are doing it manually. You are not simulating software — you are delivering a service by hand, and the customer is paying for the outcome, not the mechanism. The question is not "will they use this interface?" It is "does manually delivering this service produce the promised outcome, and is the customer willing to pay for that outcome?"

For B2B products with a specific outcome promise — reduce defect escape rate, cut inspection time by 40%, flag anomalies within one production shift — the concierge test is the only way to know whether your proposed value delivery mechanism actually delivers the value. You might have a model that performs at 99.2% accuracy in your test set. But does that accuracy translate to a measurable defect escape rate reduction for this specific customer's production line, with their specific parts, their specific lighting conditions, their specific defect taxonomy? The concierge test puts you in the production environment, manually, to find out.

🧪 Concierge script for Forge

"We want to run a two-week manual pilot on your line. We will come on-site, inspect images from your quality station manually using our classification model, and flag defects in real time. We will not deploy any hardware or software to your line — we will do this entirely through a tablet we bring. At the end of two weeks, we will compare our defect flag rate to your current inspection records and show you exactly what we would have caught that your current process missed, and what we would have flagged incorrectly. We are charging $2,500 for the two-week pilot as a commitment signal — if at the end you do not see measurable improvement, we refund it. This is how we validate that our approach actually works for your line before we build the full product."

What you learn: (1) Whether they say yes — a $2,500 commitment is a real signal. (2) Whether your model actually performs on their production data. (3) Whether the defect taxonomy you trained on matches what they actually produce. (4) What the workflow integration pain points are at the operations level. (5) What "success" actually means to this specific ops manager — it may not be accuracy rate.

A

Success criteria for a concierge pilot

Define the outcome metric in advance — ideally agreed upon with the customer at the start. "Catch X% of defects that your current inspection misses" is a testable criterion. "The team found it useful" is not. For Forge: at least 85% recall on defect classification on the customer's parts, with no more than 8% false positive rate, measured against a ground-truth sample of 200 parts assembled during the pilot.

B

Failure signals in a concierge test

The customer uses the output but does not renew, expand, or refer. This is the hardest failure to interpret honestly — founders tend to attribute non-renewal to "we were too manual" rather than "the outcome was not compelling enough." Separate the signal: if the outcome metric was hit but they did not renew, the problem is either pricing, switching cost, or you solved a vitamin-not-painkiller problem. If the outcome metric was not hit, the mechanism is wrong regardless of automation.

HOW IT WORKSSmoke test — demand before supply

A smoke test creates the impression that a product exists — a landing page, a pricing page, a signup form — and measures whether real customers take a committed action. The committed action matters: not "did they click," but "did they enter a credit card, pay a deposit, sign a letter of intent, or join a paid waitlist?" Behavioral commitment is what separates a smoke test from a survey.

Smoke tests are most powerful when demand is the primary risk — when you genuinely do not know whether enough customers exist and are motivated enough to take a first action. They are less informative for enterprise B2B products where the customer journey is long, multi-stakeholder, and requires extensive qualification. For Forge's manufacturing customers, a smoke test landing page will tell you almost nothing useful: a plant ops manager does not sign up for a SaaS inspection tool from a landing page. The smoke test is included here because it is important in many founder contexts — but you need to match the test to the actual decision your customer makes, not your preferred test format.

✗ When smoke tests mislead

The most common smoke test failure mode is confusing traffic intent with buyer intent. A landing page that gets 300 visits and 12 email signups tells you that 12 people were curious enough to type their email. It does not tell you that 12 people would pay. It does not tell you that any of the 12 are your actual ICP. It does not tell you what they expected the product to do. For enterprise B2B, a smoke test's "committed action" threshold needs to be high — a signed NDA plus a scheduled demo, a letter of intent, or a paid pilot deposit. Email signups from an ad campaign are demand theater, not demand signal.

1

Define the committed action before you build the page

The committed action must be something with a cost — time, money, or social capital. Entering a credit card on a waitlist ($1 hold) is better than a free signup. Booking a 45-minute scoped requirements call is better than clicking "interested." Signing a one-page letter of intent is better than a form fill. The higher the cost of the committed action, the stronger the signal. Set your threshold in advance: "If we get fewer than 8 committed actions from 200 targeted outreach contacts in 7 days, this segment has insufficient pull-through at this price point."

2

Build the page in one day

Headline: the outcome, not the mechanism. Not "AI-powered vision inspection" — "Catch defects your line misses today, before they reach your customer." Subhead: the specific mechanism in one sentence. Social proof: even if it is just your own credentials and the problem framing. Pricing: a real number, even if labeled "pilot pricing" or "early access." A pricing page with no price is not a smoke test — it is a brochure. The call to action: the committed action you defined in step one.

3

Drive cold traffic, not warm traffic

Sending the link to your existing network does not generate a signal about your ICP — it generates a signal about how much your network likes you. For a real smoke test, drive traffic from sources that represent your actual ICP: a targeted LinkedIn ad, a cold email sequence to a list of ops managers at tier-1 auto suppliers, an industry newsletter placement. Cold traffic tells you whether the value proposition resonates with strangers. Warm traffic tells you whether your friends are polite.

IN PRACTICERunning prototypes without deceiving customers

The most common objection technical founders raise to Wizard-of-Oz and concierge tests is ethical: "Are we not lying to customers about what we are building?" This objection contains a real concern and a misdirected conclusion. The real concern is valid — deceiving customers about what you have built damages trust and, in enterprise B2B, ends relationships permanently. The misdirected conclusion is that running these tests requires deception. It does not.

1

Wizard-of-Oz: disclose the manual backend at the right time

You do not need to announce at the start of the session that "there is a person behind the curtain." You need to avoid making explicit false claims: "Our AI processes this in real time" is a lie. "Results typically arrive in 2–3 minutes" is a true statement about a timeline, not a lie about the mechanism. After the session, disclose: "To be transparent, this session was manually processed by our team as part of our validation process. The production system will automate this. We wanted to test the workflow before building the automation." Customers consistently respond positively to this — it signals seriousness and rigor, not deception.

2

Concierge: transparency is the feature

In a concierge test, there is nothing to hide. You are explicitly telling the customer: "We are going to deliver this service manually for two weeks." The transparency is the trust signal. Customers in enterprise B2B respond better to a founder who says "we will come on-site and prove this works for your specific line before we productize it" than to one who shows a polished demo of software that has never seen their data. Manual delivery with full disclosure is not a workaround — it is a better test design than a demo.

3

Smoke test: the product does not exist yet — say so on the page

"We are building X and opening early access" is honest. "We are accepting applications for our pilot program" is honest. "Sign up and we will contact you when we launch" is honest. What is not honest: a pricing page implying a product exists when nothing is built. The benchmark: if a customer paid and then found out the product was not yet built, would they feel deceived? If yes, the page was misleading. If no — if the page was accurately described as a waitlist or pilot application — there is no ethical issue.

🔑 The right framing for every prototype conversation

"We have validated that this problem is real. We are now testing whether our proposed solution actually solves it in your environment before we build the production system. You are getting an early look at the mechanism — and we are getting the real-world data we need to build it right. This benefits you: if we discover the mechanism is wrong, we can fix it before you depend on it." Almost every enterprise customer responds to this framing with more trust, not less.

SEE ITPrototype Sprint Tracker — 5-day plan with daily go/no-go

⚙ Interactive · Prototype Sprint Tracker

Plan a 5-day prototype sprint. Each day has specific deliverables and a go/no-go checkpoint. Check off deliverables as you complete them. The tracker will alert you if the estimated scope of your prototype has crept beyond what a pre-production experiment should be — and prompt you to scope-cut before writing production code.

Forge context: You are running a 5-day sprint to set up and execute a Wizard-of-Oz prototype on a single manufacturing customer's line before committing to the full edge device + dashboard MVP build. The goal: confirm the workflow, input format, output format, and latency requirements before writing a line of production inference code.

5 days
1 person
Sunk Cost Alarm — Prototype scope has grown beyond a prototype.
Your estimated prototype build time exceeds 2 weeks (10 person-days). At this scope, you are building an early product, not a prototype — and the risk of sunk cost justifying continued building rather than a go/no-go decision is high. Scope review required: What is the single most important thing this prototype needs to test? Reduce the scope to test only that thing. If the test genuinely requires 2+ weeks of build, you may have skipped the simpler test that would give you the signal first.
Sprint progress 0%
Day 1Day 2Day 3Day 4Day 5
Day 1 · Design the test

Define exactly what you are testing before you build anything. The deliverables below force you to externalize the design decisions that most founders make implicitly — and get wrong.

  • Write the single riskiest assumption this prototype is testing (one sentence, specific and falsifiable)
  • Map the exact customer workflow: what they do, what they submit, what they receive, what action they take as a result
  • Choose the prototype type (Wizard-of-Oz / concierge / smoke test) and write one sentence justifying the choice against the riskiest assumption
  • Write the go/no-go criterion: what specific customer behavior in this session would mean the prototype succeeded, and what would mean it failed
  • Identify the one person on the team running the manual backend — this is not optional, and it is not "the whole team," it is one named person with a specific role
End-of-day go/no-go checkpoint
✓Go: All five deliverables are completed and written down. The riskiest assumption is specific enough that a customer interaction could falsify it. The go/no-go criterion is pre-committed, not vague.
✗No-go (stop, do not proceed): The riskiest assumption is "does the product work?" (too vague) or you have not yet identified the customer to run the test with. Do not build until you can name the specific assumption and the specific customer.
Day 2 · Build the minimum interface

Build only what the customer touches. Not the backend. Not the processing layer. The submission mechanism, the result display, and nothing else. The constraint: everything built today must be buildable by one person in one day. If it is not, scope it down.

  • Submission interface is live and accessible by URL (a form, a shared folder, an upload endpoint — no production infra required)
  • Result delivery mechanism is set up: how will you send the output back? (Email, Slack message, a simple web page you update manually, a shared doc — choose the simplest option)
  • Manual backend process is documented step-by-step — if you are hit by a car on Day 3, someone else can run the simulation using only this document
  • Internal test run completed: you run through the whole workflow yourself as if you were the customer, submitting a real sample and producing a result
End-of-day go/no-go checkpoint
✓Go: The internal test run produced a result within the target latency, the submission interface worked without guidance, and the result format is what you designed on Day 1.
✗No-go: The internal test run took more than 3× the target time, or you had to guide yourself through the interface. Do not schedule the customer session until the internal run works without friction.
Day 3 · Confirm the session

Recruit and confirm the specific customer (or customers) who will participate. This is not scheduling a demo. This is setting up a structured prototype session with a participant who knows what to expect.

  • Customer session confirmed for Day 4 — specific person, specific time, specific access (on-site, remote, or hybrid)
  • Pre-session briefing sent: what the customer will be asked to do, how long it will take, what they will receive, and the disclosure language ("results are manually processed as part of our validation process")
  • Observation protocol written: specifically, what behavior you are watching for — not "are they confused?" but "at which step do they stop without prompting?" and "do they use the output to make a decision without being asked?"
  • Post-session debrief script prepared: three specific questions that probe the go/no-go criterion, plus one open question designed to surface problems you did not anticipate
End-of-day go/no-go checkpoint
✓Go: Session is confirmed with a real customer (not a friend, not a teammate posing as a customer). Observation protocol is specific enough to generate unambiguous data.
✗No-go: The "customer" for Day 4 is a warm contact who already knows about the product and is pre-disposed to say positive things. A test where the customer cannot produce a negative result is not a test.
Day 4 · Run the session

Run the prototype session. Your job is to observe, not to pitch, guide, or rescue. Every time you intervene to help the customer, you contaminate the data.

  • Session completed — customer went through the full workflow from start to finish
  • Observation notes written during the session: every point where the customer paused, asked a question, expressed confusion, or expressed a strong positive or negative reaction
  • Post-session debrief completed with the three scripted questions — answers recorded verbatim, not summarized
  • Go/no-go data mapped to the pre-committed criterion from Day 1 — not reinterpreted, not rationalized, just mapped: did the behavior you observed match the go criterion or the no-go criterion?
End-of-day go/no-go checkpoint
✓Go signal: Customer completed the workflow without being guided; used the output to make a real decision; described the experience with a specific, unprompted positive statement about the workflow fitting their operation.
✗No-go signal: Customer required guidance at any step; output was received but not acted on; customer said "interesting" but could not articulate how this would change their workflow; latency was described as unacceptable even when told it would be automated. Any of these signals the mechanism needs redesign.
Day 5 · Render the verdict

The sprint ends with a written verdict — not a meeting, not a discussion, a written document that records the evidence and the conclusion. This is the artifact that either authorizes the next stage of build or triggers a redesign.

  • Verdict document written: state the riskiest assumption tested, the evidence collected, and the go/no-go conclusion — one page maximum
  • Specific learnings documented: what did you learn about the customer workflow that you did not know before? (If the answer is "nothing new," the test was too easy or the customer was too warm)
  • If go: the next build milestone is defined — what specific component gets built first, with what success metric, and what is the next prototype/test after that build?
  • If no-go: the specific mechanism failure is identified and a redesign hypothesis is stated — not "we need to improve it" but "the failure was X, which suggests the mechanism should be Y instead"
Sprint final verdict
✓Authorized to build: Go verdict on Day 4, verdict document written and shared, specific next milestone defined. You have earned the right to write production code for this specific mechanism.
✗Return to redesign: No-go verdict, or go verdict without a written document and next milestone. "We think it went well" is not a sprint close. The discipline of writing the verdict is the discipline that prevents the sunk-cost ratchet from converting a failed test into a production commitment.
Deliverables completed
0 / 20
Current day
Day 1
Sprint status
In progress

A few things to notice in this tracker. First, Day 1 is entirely about design — you should not write a single line of code until the riskiest assumption and the go/no-go criterion are externalized in writing. The most common sprint failure is starting to build (Day 2 work) without completing Day 1. Second, the sunk cost alarm at the scope slider is not a warning about time — it is a warning about mindset. When a prototype requires more than two weeks of work, founders have typically already unconsciously reclassified it as "the actual product" and the go/no-go checkpoint becomes uncomfortable. The alarm prompts a scope-cut before that reclassification happens.

FORGEThe Forge prototype decision — before the edge device gets ordered

Forge has signed three paid pilot contracts at $8K each (the Stage 2 milestone). The contracts commit Forge to deploying an edge device and dashboard at one manufacturing site. Before ordering hardware and writing the production inference pipeline, there is still a prototype to run — and the specific riskiest assumption at this stage is not "does the model perform?" (you have your ablation study). The riskiest assumption is: does the edge device + dashboard workflow fit how this specific operations team actually works, and will they use the dashboard outputs to change their inspection decisions within the first 30 days?

1

The Wizard-of-Oz layer for Forge's hardware prototype

Before deploying the actual edge device, Forge runs a 5-day Wizard-of-Oz: a laptop running the inference model is positioned at the quality station (not permanently installed — just a laptop on a cart), connected to the customer's existing camera feed via a temporary cable. The dashboard is a Google Sheets document with a custom App Script that displays the last 10 classifications with confidence scores. An ops manager receives a Slack message from Forge when a high-confidence defect is flagged. There is no edge device, no production deployment, no infrastructure commitment. The test: does the ops manager look at the Slack message and pull the flagged component for re-inspection? Do they do this consistently over 5 days?

2

What the Wizard-of-Oz test actually answers

Go signal: Ops manager checks and acts on at least 7 of 10 flagged components within 15 minutes of the Slack notification, without being reminded, and on Day 5 asks "when does the permanent version get installed?" Failure signal: Ops manager looks at the first two alerts, defers to human inspection on all of them, and on Day 3 says "I'm not sure my team will change what they do based on this." That failure signal means the workflow integration is wrong — the alert mechanism, the authority structure, or the actionability of the output needs redesign before you order $40K of edge hardware.

3

Why this is not "cheating"

The customer paid $8K for a pilot. The Wizard-of-Oz layer is disclosed: "Before we permanently install the edge device, we are running a 5-day configuration test to make sure the alert format and dashboard layout match how your team operates. We want to get the integration right before the permanent install." This framing is honest, professional, and — in enterprise B2B manufacturing — signals exactly the kind of diligence that operations managers respect. The customer is not being deceived; they are getting a more thorough setup process than they would have received from a vendor who just shipped hardware and walked away.

🔑 The Forge milestone this unlocks

The Stage 2 milestone requires "first activation data collected" and "evidence that customers who complete onboarding see a measurable defect detection improvement within the first 30 days." A 5-day Wizard-of-Oz prototype at the first paid pilot site gives Forge the activation data — specifically, whether the workflow integration produces spontaneous behavior change — before committing the full edge device deployment. If the prototype fails, Forge has five days of data that will inform a redesign. If the prototype succeeds, Forge has the activation evidence to anchor the measurement framework that proves the 30-day improvement claim. Either way, the data from the prototype is more valuable than the data from a deployment that assumed the workflow would work.

Prototype-first vs. build-first: Forge timeline Build-first 6 weeks: build edge device + dashboard Deploy Wk 8: workflow failure discovered Redesign + rework Proto-first Wk 1: WoZ Wk 2: fix found Weeks 3–5: build with correct design Wk 5: deploy, works Wk 0 Wk 1 Wk 2 Wk 3 Wk 4 Wk 5 Wk 6 Wk 8+ Saved: 3+ weeks of rework + customer trust
Prototype-first saves time not by skipping a step — it saves time by discovering the workflow failure in week 1 instead of week 8. The build-first approach is not faster; it is just a delayed failure at higher cost.

WEAKNESSWhere this bites

✗ The "cheating" fallacy — feeling like a prototype is not the real work

The most damaging failure mode in prototype strategy is not running the wrong type of test — it is not running any test because it feels like avoidance. Technical founders experience a specific psychological cost from running a Wizard-of-Oz instead of building the actual system. The system builder's identity is engaged by production code, not by manually routing Slack messages. This feeling of "not really building yet" is the primary reason founders skip prototypes and jump to production. Name it explicitly for what it is: a bias toward activity that feels like progress over activity that generates evidence. A prototype is not a workaround for not being able to build the real thing. It is a technique for building the right real thing rather than an expensive wrong one. The most expensive version of building the wrong thing is always production-quality.

✗ Moving the goalposts when the prototype fails

The go/no-go criterion must be written before the prototype runs, not after. Founders who fail to pre-commit the criterion almost always interpret ambiguous results as a go signal: "The customer was a bit confused but in general it seemed promising." "They didn't act on it this time but that's because they're not used to the tool yet." "The latency was a problem but that was because of the Wizard-of-Oz setup, not because of the actual mechanism." Each of these rationalizations has a kernel of plausibility. That is what makes them dangerous. Pre-committed criteria are the only protection against the natural human tendency to reinterpret evidence to match a conclusion you wanted to reach.

✗ Running the prototype with the wrong customer

A Wizard-of-Oz session run with a friendly, motivated customer who is already invested in your success is not a prototype — it is a demo with extra steps. The customer for a prototype session must be someone who will behave exactly as they would if this were a real product: no prior relationship with the founder, no stake in the outcome, no reason to be polite rather than honest. In enterprise B2B, this typically means the pilot customer should not be the same person who championed the pilot internally — they should be an end user who was told "we are deploying a new inspection tool, try it for the next week." Champions are motivated to succeed; end users will tell you the truth.

KEY INSIGHTHow this connects

  • 2.2 · What MVP Actually Means — lesson 2.2 established that an MVP is the cheapest test of the riskiest assumption, not the smallest complete product. The three prototype strategies in this lesson are the specific techniques for running that cheapest test before any production build begins. The Wizard-of-Oz, concierge, and smoke test are what "cheapest test" looks like in practice.
  • 2.3 · Scoping the MVP — Ruthless Subtraction — lesson 2.3 identified the specific features of the MVP by removing everything that does not test the riskiest assumption. This lesson takes that scoped feature set and asks: before we build even the scoped version, which of these features can be tested with a prototype? The prototype sprint is what you run on the highest-risk feature before you build it, even in its MVP form.
  • 2.5 · Building the MVP — Speed Over Polish — lesson 2.5 covers what happens after a successful prototype sprint: building the actual MVP. The prototype verdict is the authorization to begin that build. If the prototype produced a go signal, you have specific knowledge about the workflow, input format, output format, and latency requirements — and the MVP build becomes a substantially more informed process than it would have been without the prototype.

The prototype sprint sits between scoping and building as a deliberate deceleration before acceleration. Most founders experience it as a delay. The founders who have run a prototype and then built the wrong thing anyway — because they skipped it — experience it as the most expensive mistake in their company's history. The five days you spend on a prototype are not lost from the build cycle; they are the insurance premium that makes the build cycle worth beginning.

GLOSSARYKey terms introduced

Wizard-of-Oz test
A prototype technique where the customer interacts with an interface that appears to be a working automated system, but behind the scenes a human is performing all the processing manually. Tests whether the product experience and workflow mechanism work for real customers before the automated system is built. Named after the film — the wizard behind the curtain.
Concierge test
A prototype technique where you deliver the product's promised value manually, with full customer disclosure, to determine whether your mechanism actually produces the outcome you claim. Different from Wizard-of-Oz in that the customer knows it is manual. Tests outcome delivery, not product experience.
Smoke test
A demand-generation prototype that creates the impression of a product and measures whether real customers take a committed action (pay a deposit, sign up, sign a letter of intent) before the product is built. Tests demand existence. A committed action threshold must be defined in advance or the smoke test produces ambiguous results.
Go/no-go criterion
A specific, pre-committed criterion that determines whether a prototype session succeeded or failed. Must be written before the prototype runs, not after. The specific customer behavior that must occur for a go signal. Without pre-commitment, founders systematically rationalize ambiguous results as go signals.
Sunk cost ratchet
The psychological mechanism by which prior investment makes it progressively harder to stop building, even when the go/no-go data says to stop. In prototype strategy, the sunk cost ratchet activates when the prototype scope grows large enough that stopping feels like wasting the build investment. The sunk cost alarm fires before this reclassification happens.
Prototype scope creep
The gradual addition of features and complexity to a prototype until it requires the same effort to build as the production version it was meant to replace as a test. Prototype scope creep is almost always driven by the same urge to build the real product that the prototype was designed to defer. The test: if the prototype takes more than two weeks to set up, it has probably become the product.
Pre-committed criterion
Any success criterion, threshold, or go/no-go rule that is written down and agreed upon before the data is collected. The same discipline as a Bayesian falsification criterion, applied to prototype evaluation. Pre-commitment is the only reliable protection against post-hoc rationalization of ambiguous results.

ACTIVE RECALLCheck your understanding

Answer in your own words first, then reveal.

1A founder running a Wizard-of-Oz test discovers that customers consistently need guidance at step 3 of a 5-step workflow — they stop without prompting and wait to be told what to do next. Is this a go signal, a no-go signal, or something else? What should the founder do?›

This is a no-go signal for the current workflow design, but it is not a no-go signal for the product — it is a specific failure signal that reveals a design problem. The founder should: (1) Not rationalize this as "they just need to get used to it" — in a Wizard-of-Oz session, every guidance intervention contaminates the signal; (2) Treat step 3 as a confirmed broken point in the UX, regardless of how the rest of the session went; (3) Specifically investigate what the customer expected to happen at step 3 — this is data about the mental model mismatch, not just a UX bug; (4) Redesign step 3 before running another session, not after building the production system. The correct outcome is: run a second Wizard-of-Oz session with the redesigned step 3, not build the full product and add a tooltip at step 3.

2Why is a concierge test a fundamentally different kind of signal than a Wizard-of-Oz test, even though both involve manual delivery? When would you choose one over the other?›

A Wizard-of-Oz test primarily tests the product experience — the workflow, the interface, the inputs and outputs, the customer's ability to use the mechanism. The key question is: "Does this experience work, regardless of whether the automation is built?" A concierge test primarily tests outcome delivery — whether the service, manually delivered, actually produces the promised result in the customer's environment. The key question is: "Does this mechanism produce the outcome we claim, in this customer's specific context?" Choose Wizard-of-Oz when your riskiest assumption is "customers will adopt this workflow" — when you need to know whether the mechanism fits the customer's operation before you build the automation. Choose concierge when your riskiest assumption is "our mechanism actually produces the outcome it claims" — when the model accuracy on your test set has not yet been confirmed on a real customer's production data with their specific parts, lighting, defect taxonomy, and workflow. For Forge specifically: Wizard-of-Oz answers "will ops managers use this?" Concierge answers "will our CV model catch defects that currently escape their process?"

3Forge's 5-day Wizard-of-Oz sprint produces a go signal: the ops manager checked and acted on 8 of 10 flagged components, and on Day 5 asked when the permanent device would be installed. A founder says: "Great, let's order the hardware and build the production pipeline." What critical step are they skipping?›

They are skipping the verdict document — the written record of what was tested, what was observed, and the specific learnings that should inform the build. "The ops manager acted on 8 of 10 flags" is a go signal, but without documentation it will be forgotten or reinterpreted during the build. The verdict document should capture: (1) what the specific riskiest assumption was; (2) what the exact go/no-go criterion was; (3) what behavior was observed that met the criterion; (4) any unexpected behavior — what the ops manager did that was not anticipated, including what they said about the alert format, timing, and integration with their existing workflow; and (5) the specific first build milestone that the go signal authorizes, with a success metric for that milestone. Without the verdict document, the learnings from the prototype will not survive the transition to the build phase — institutional knowledge dies in the gap between prototype and build.

4Why does the sunk cost ratchet specifically activate when a prototype scope grows beyond two weeks — and not earlier? What is the psychological mechanism, and how does the sunk cost alarm in the sprint tracker interrupt it?›

The sunk cost ratchet activates at the two-week threshold because that is approximately the point at which the prototype has accumulated enough invested effort that stopping it feels like "wasting" the work done so far — rather than efficiently generating a signal that prevents a larger waste. Below that threshold, the investment feels recoverable: "we only spent three days on this, no big deal." Above it, the investment becomes identity-attached: "we have spent three weeks on this, it needs to justify that investment." The psychological mechanism is that the prototype has been unconsciously reclassified as "the product" — the founder is no longer running an experiment, they are building a thing that they have started to care about. The sprint tracker's sunk cost alarm interrupts this reclassification before it solidifies by making the scope creep visible while there is still a decision to make: before the investment generates enough momentum that the go/no-go criterion can no longer produce a genuine no-go verdict. An alarm that fires after the reclassification is useless; it has to fire before.

Next: building the MVP with speed — now that you have earned the right to build →