Product Judgment When the Draft Is Free
What changes when every artifact arrives fluent: why format stopped signalling rigour, why "cheap to build" isn't "worth building," and how to read a document for traceability.
Chapter 7 · 4 ideas · 13 checks · 16 min
Start here
A Slack thread, Tuesday afternoon.
Eight months ago the team rejected a feature: bulk supplier onboarding by CSV import. The rejection memo is still linked in the thread. It rejected the feature on demand: three customers had asked, all three had fewer than fifty suppliers, and the manual flow took each of them about twenty minutes a year.
Today an engineer has built a working prototype in two days with a coding agent, and posted a demo video. It works. It is genuinely good.
The thread is enthusiastic. The engineer adds: this used to be a quarter of work and now it's a week. Surely we just ship it?
Everyone can see the prototype. Nobody has reopened the memo.
And here is what makes this hard rather than obvious: refusing free value looks like stubbornness. The prototype exists. The person who built it is pleased and did good work. Saying no costs you something socially, and the argument for yes, it's basically free now, feels like new information.
It is new information. It is just information about a different question than the one the memo answered.
So: when the cost of producing something collapses, what actually changed about whether to do it?
Core concepts
Each idea is a short read, one picture and one quick check.
Idea 1 of 4
Which risk actually moved
A rejected idea comes back with a new argument, and the argument is true. The room relaxes. Before it does, ask what the new fact is evidence about.
Chapter one gave you four risks: value (will anyone choose it), usability, feasibility (can we build it) and business viability. The CSV import was rejected on value. The prototype is evidence about feasibility. Feasibility moved; value did not move at all. When new information bears on a different risk from the one the idea was rejected on, it does not reach the original decision.
Picture it
Rejection memo · CSV import · 8 months ago
- Three customers asked. All have under 50 suppliers. (highlighted)← the reason (value)
- Manual onboarding takes each about 20 minutes a year. (highlighted)← nobody has re-checked
- Build estimate: about a quarter of one team. (struck out)the only line that changed
- Decision: not now. Reopen if long-list customers ask. (circled)the way back in
Feasibility moved. Value didn't.
Check yourself
Which questions does the two-day prototype answer?
Can we build bulk import with our stack?
Can a working version be built in days rather than a quarter?
Do enough customers have supplier lists long enough to need it?
Will support cope with malformed files and duplicate suppliers?
Who carries the import path through next quarter's supplier-data migration?
Does the import run end to end on a sample file?
Go deeper
How to use it. When a previously rejected idea returns with a new argument, ask one question before anything else: which of the four risks does the new information bear on, and which risk did we reject it on? If those are different risks, the new information does not reach the original decision. It may still be worth revisiting for other reasons, but it has not answered the objection.
Then price what is still not free. The build got cheap. These did not: surface area in the product, support load, documentation, the next migration that has to carry this feature along, and the attention of whoever maintains it. A feature that costs a week to build and then exists for six years is mostly not a build cost.
How to spot it. Look at the argument's form. "We can build this in a week now" is a statement about cost. If it is being used to answer an objection about demand, the sentence has quietly changed the subject, and everyone in the thread is agreeing with it.
Back to the Slack thread. Which risk moved: feasibility. Which risk it was rejected on: value. The prototype does not reach the original decision. What is still not free: the import path becomes a permanent surface, someone supports it, and every future change to supplier data has to carry it. So the honest reply is neither "ship it" nor a flat no. It goes back to the objection the idea was rejected on, asks whether that has changed, and treats the prototype as what it is: good work that answered a different question.
One thing that has changed. Feasibility risk has genuinely fallen for a large class of software. That changes the mix rather than removing it: when building is cheap, value becomes the binding risk, and business viability (support, legal exposure, brand) becomes the quiet killer, because none of it got cheaper when generation did.
Idea 2 of 4
Fluency stopped being evidence
A twelve-page strategy document lands the night before the meeting. Clean headings, a risks table, a phased plan, confident prose. For about forty years that polish was weak evidence that thinking had occurred: producing it took enough work that the polish went with the substance.
That link broke. The reading habit did not. You now receive documents that look exactly like the good version, in which no claim is sourced and no number can be traced. So read for traceability, not structure: find the two or three claims the conclusion rests on (the load-bearing claims), follow each to where it came from, and mark everything else unverified.
Check yourself
You have forty minutes with this memo before the meeting. How do you spend them?
Picture it
Market-entry memo · 12 pages
- 40% of our trial sign-ups now come from Europe. (circled)load-bearing. trace it
- No local rival offers invoicing inside the app. (circled)load-bearing. trace it
- Phased rollout across three quarters.
- Executive summary, glossary, appendix. (struck out)polish, not proof
Two claims carry it. The rest is unverified.
Go deeper
How to use it.
- Identify the two or three claims the conclusion actually rests on. Most documents have surprisingly few; the rest is context and elaboration.
- Ask where each one came from, and follow it to the source.
- Mark everything else explicitly as unverified rather than pretending you checked it.
The third step is the one people skip, and skipping it is what turns a fast read into a false sense of having reviewed something.
Why you cannot just check everything. Generating a plausible claim is now nearly free; checking one costs roughly what it always did. Where those two costs diverge that sharply, the volume of unverified plausible material grows without limit and your attention becomes the binding constraint. Trying to check everything equally means either burning a day or doing it superficially and calling the document checked. The second is worse than not checking, because it produces confidence.
How to spot the trap. Fabrications are shaped, by the generation process rather than by anyone's intent, to pass exactly the cheap checks a busy reader runs: a plausible source, a real-sounding figure, a link that opens. A link opening is not verification. The link opening to a document that makes the claim is.
How to spot it in your own reading. Notice when you have formed a favourable impression of a document and cannot name one specific thing in it you checked.
One thing that has changed. This whole idea is new. Until recently a fluent document was expensive to produce, so fluency was a rough proxy for work done. It no longer is, and the proxy still runs in every reader's head by default.
Idea 3 of 4
The verification cost decides what to delegate
Someone proposes handing a task to a model because the model does it in seconds. It looks like a question about capability. It is mostly arithmetic with three terms: how long the task takes a person, how often the model gets it right, and how long it takes to check the output. The third term is the one people leave out, and it usually decides.
Delegation wins when the model's attempt plus checking plus fixing what it got wrong costs less than doing the task directly. So a task that is fast to do and slow to check stays human, even at high success rates. A task that is slow to do and fast to check is worth delegating even at mediocre ones.
Picture it
- Reformat 400 supplier records
- Draft release notes from merged changes
- Data migration that fails silently
- Summarise a customer call you sat in on
- Shaded corner: Delegate first
Check yourself
A team lead wants a model to draft replies to supplier pricing disputes. A person takes 10 minutes per dispute. Checking a draft means re-reading the contract: about 15 minutes. The model is right about 85% of the time. What's the call?
Go deeper
How to use it. Estimate all three terms before deciding. Then remember the leverage point: how fast output can be checked is something you design. Asking for output in a checkable form (sources attached, the underlying quotes included, the load-bearing claims separated out) moves a task from "slow to check" to "quick to check". That is a decision you make when you delegate, not a fixed property of the task.
How to spot the gap. A workflow proposal with time-saved estimates and no checking cost anywhere. The saving is computed against doing the work; the real comparison is against doing the work and checking it.
One thing that has changed. What got cheap is the prediction part of the work: drafting, filling in, forecasting. The judgment part did not: knowing what an error costs, what the output is for, and when it is wrong. Delegate toward the first; keep and invest in the second. A model can forecast churn; it cannot decide what churn is worth preventing at what price.
Idea 4 of 4
More output at constant outcome
A team adopts AI coding tools. Two quarters later it ships nearly twice as much, and everyone can feel the speed. Activation and retention haven't moved.
Chapter one's split returns here. Output is what the team shipped; outcome is the change in customer behaviour that shipping produced. When output rises and outcomes stay flat, resist the two easy readings: that the tools aren't working, or that outcomes will follow with time. The likelier reading is that production speed was never the constraint. Knowing what to build was, and the team is now solving the wrong problem faster.
Check yourself
From a quarterly update. Output or outcome?
Pull requests per engineer doubled.
More new teams invite a colleague in their first week.
Releases went from monthly to weekly.
Fewer accounts cancel at renewal.
Discovery summaries produced per quarter tripled.
Go deeper
How to use it. For each item the team shipped last quarter, write the behaviour it was meant to change and what actually happened. If most rows say "not measured", the team has been shipping bets without settling them.
How to spot it. Velocity metrics up, release counts up, behavioural metrics flat or unmeasured. It looks like success in every artifact the team produces about itself.
One thing that has changed. Teams adopting AI tooling frequently ship substantially more while their outcomes stay flat. This is not mysterious once you have the vocabulary: the tools relieved a constraint the team didn't have.
Worked examples
Make the call yourself first. The reasoning opens after you choose.
Example 1 of 3
The competitive analysis nobody had read
Freya, a head of product, receives a fourteen-page competitive analysis the night before a strategy offsite. It is organised and well written, with a summary table of nine competitors: positioning, pricing, recent product moves. Its recommendation depends on two claims: that the two largest competitors have both shipped one particular capability in the last six months, and that a named analyst firm projects the segment growing at 28% a year. She has forty minutes, not a day.
Check yourself
How should Freya spend the forty minutes?
Example 2 of 3
The workflow that saved time and cost more
Tariq, an engineering manager, proposes using a coding agent for a category of routine data migrations. They change customer data, and a mistake doesn't always show in the diff. These tasks average four hours each; the agent finishes one in about twenty minutes; the team does roughly fifteen a month. Projected saving: about 55 hours a month. The number is honest, and the agent genuinely does the work.
Check yourself
What should the reviewer ask before approving it?
Example 3 of 3
The team that shipped twice as much
A 40-person product organisation adopts AI tooling broadly. Two quarters later, pull requests per engineer have roughly doubled, cycle time is down 40%, and releases are more frequent. Everyone can feel it. Activation, retention and expansion revenue are all within noise of where they were.
Check yourself
What is the likeliest explanation?
Case studies
Real situations with more than one defensible reading.
Case 1 of 1
A team shipping substantially more at flat outcomes
An invented composite, built from the pattern rather than any real company.
A B2B product company, 38 people in product and engineering, £11m annual revenue. Twelve months ago it adopted AI coding assistance broadly, plus model-assisted synthesis of discovery interviews and a generated-first approach to PRDs (product requirements documents: the written spec a team builds from). Engineering satisfaction is up and the board deck leads with velocity. Twelve months ago, nine people on the product team spoke to a named customer in a typical month; last month, two did. The CEO has asked why revenue has not followed, and nobody knows.
Check yourself
Tap the lines that report output as if it were progress.
Board update · twelve months on AI tooling
Found 0 of 3.
Check yourself
The CEO asks for one change next quarter. Which addresses the binding constraint?
What great operators do
The rules this chapter's scenarios test for, and how to tell when someone follows them.
Rules to keep
Before you open each card, say what you'd look for.
Common failure patterns
How smart people get this wrong. Find each one in the wild.
Trap 1 of 3
Fluency mistaken for rigour
What it looks like. A well-structured, confidently worded document, with the right headings, a risks table and a phased plan, in which no claim is sourced and no number can be traced. It reads like the good version of this document.
Check yourself
Tap the lines the plan rests on that nobody can trace.
Plan · launch a self-serve tier
Found 0 of 2.
Why smart people do it. Format was a real signal for decades: producing a polished strategy document used to require the thinking that justified it. That link broke, but the reading habit didn't, and a reading habit is not a belief you can simply update.
The correction. Read for traceability rather than structure. Pick the two or three load-bearing claims and ask where each came from. Treat "it reads well" as carrying no information about whether the analysis happened.
Trap 2 of 3
Cheap-to-build therefore worth building
What it looks like. A previously rejected idea returning with "we can build this in a week now" as the new argument. The value case is unchanged; only the cost estimate moved.
Check yourself
Tap the lines that treat the cheap build as the whole story.
Slack · #product · Thursday
Found 0 of 2.
Why smart people do it. The cost drop is real and dramatic, and it feels like new information. It is, about feasibility, which was rarely the binding risk. It also arrives attached to a working prototype and an enthusiastic colleague, which makes disagreeing socially expensive.
The correction. Ask which of the four risks the new capability actually changed. If the idea failed on value, it still fails on value, and it now also carries maintenance, support and surface-area cost.
Trap 3 of 3
Output mistaken for progress
What it looks like. A retro or update listing shipped work as accomplishment. Velocity up, releases up, the team visibly productive. No behavioural metric appears, or one appears without a baseline.
Check yourself
Tap the lines that report shipping as if it were the result.
Q3 update · onboarding team
Found 0 of 2.
Why smart people do it. Output is measurable, attributable and immediate; outcomes are noisy, lagging and shared. Under pressure the measurable thing wins. With AI tooling the output number rises sharply, which makes the pattern both more tempting and more expensive.
The correction. Pair every shipped item with the behaviour it targeted and the observed change. Where none was measured, say so: an unmeasured launch is an unevaluated bet, not a success.
Cheat sheet
The whole chapter on one card. Save it or share it.
Product Judgment When the Draft Is Free
- 1When building gets cheap, ask which risk actually moved.A prototype answers "can we build it", rarely "does anyone need it".
- 2A feature costs a week to build and years to keep.Price the support, the surface area and every migration that must carry it.
- 3Polish no longer means the thinking happened.Read for where each claim came from, not for how the document is laid out.
- 4Find the two or three claims the call rests on. Check those.Then label the rest unverified, out loud.
- 5Count the time to check, not only the time to do.Quick to do and slow to check stays human. Ask for output you can check.
- 6More output, flat outcomes? The constraint was never speed.For each shipped item: what behaviour was it for, and what happened?
- 7Write down what would change your mind.It is the line least likely to survive a generated draft.
Memes
The failure patterns, one picture each. For the group chat.
Your turn
Make the call
The checkpoint is a launch memo drafted with an AI assistant and then edited, the same one chapter one used, on purpose: the memo you read there with a four-risk checklist is now something you read for traceability. You decide which of its soft claims would change the decision if it were false, then approve, hold or condition the launch date. Where newer cases from this chapter appear beside it, they replay the Slack thread from Start here and a board recommendation built on a doubling in output.
The trap. "It was drafted with AI, so redo the analysis by hand" sounds like rigour. It isn't: polish carries no information either way, and rewriting the memo doesn't find the one claim the launch rests on.


