Polish No Longer Signals Readiness

Sources#

• OpenAI Codex lead on the new shape of product work

Summary#

Andrew Ambrosino's (OpenAI Codex) observation about a signal that broke when implementation got cheap: the medium of an artifact used to carry baked-in information about where in the process it sat. "If you're seeing something that feels like the app in production, that means it's late in the process, that assumptions have been derisked, that design has looked at this, that it's a good business goal." That inference held because it was hard to get resources to build the thing until it was properly derisked — polish was expensive, so polish was evidence of maturity. Cheap implementation severs the link: a "90-person multiplayer exploration" can look "so production ready" while actually being early design-process work. The failure mode is over-anchoring — "enough people at a company see that and they're like, can we release this now?" — when the honest answer is "no, this is exploration, nobody's just saying that."

Evidence note. practitioner-opinion — a product leader's first-hand account of a failure mode at OpenAI, not measured.

The severed signal#

Two things that used to travel together, now decoupled:

• Before: medium/fidelity → process-stage. Production-fidelity ⇒ derisked, reviewed, business-approved, ready. (Prototyping tools like Figma/Origami had already strained this by "fast-forwarding" prototypes earlier — the "can we just ship the prototype?" executive meme — but that strain was bounded.)
• After: medium/fidelity → nothing. "Those things are sort of divorced." You can pull all of the implementation into the exploration, so a prod-looking artifact says nothing about whether the assumptions behind it are derisked, whether it's the right model of where the research is going, or whether it's right for the business.

The primal-mark hazard is the deeper version: Lenny names the design idea that the first mark is what everyone responds to, so an over-polished early prototype "over-anchors" the team on an exploration that was never meant to be the answer — you respond to the artifact instead of the bigger idea.

The remedy: state the stage explicitly#

Ambrosino's fix is not to slow down but to re-attach the stage signal by hand — say out loud where in the process something is, because the medium no longer says it: "It's really important to start saying, look, we can have prototypes, we can have documents — are we clear about what this is doing?" This is why he holds that the "design process proper" is dead but the process overlay is more important than ever: the day-to-day design-process ritual (user research → divergence → convergence) is obsolete, but the meta-awareness of "we are at this stage; this is exploration, not a shippable" is now load-bearing precisely because nothing else supplies it. (He agrees on this with Jenny, head of design for Claude Code / Cowork, who argues the design process is dead and design now "steers as things move" — Ambrosino adds the stage-labeling caveat.)

Mechanisms the corpus already holds that re-supply the missing signal: "research preview" branding is an explicit stage-label bolted onto a shipped artifact; treating a working build as "an artifact we can test against for future models" (Build for the Next Model) re-labels prod-looking code as not yet shippable.

Connections#

• Risk-Tiered Auto-Approval — the structural workaround at the merge gate: PR state, a path/keyword deny-list, and a diff-size ceiling are all properties polish cannot fake, which is why PostHog's auto-stamper puts them ahead of its LLM check rather than behind it. A gate that leads with a model inherits the same disarming this page describes
• Design by Selection — the practitioner countermeasure: "wireframe first when fidelity doesn't matter" deliberately withholds polish so the artifact reads as early and feedback lands on structure rather than visuals
• Why AI Lags at Design — a model can emit prod-looking polish (mean-reversion to "good-looking") while missing the semantic abstraction that makes design maintainable
• Andrew Ambrosino — articulates the severed signal and the "state the stage" remedy
• Implementation Abundance Inverts Product Work — the cause: cheap implementation across every medium is what lets explorations look shippable
• Prototype Over PRD — the prototype-as-spec method inherits this hazard directly; a fast, polished prototype is exactly the artifact that over-signals readiness
• Build for the Next Model — "this isn't working, it's a bad feature" vs. "it's an artifact to test against future models" is the same relabeling: prod-looking ≠ ready
• Problem-Solution Fit Discipline — sibling trap: prototype-as-evidence (proves the build was tractable, not the problem real) alongside prototype-as-readiness (looks shippable, isn't)
• AI Native Product Cadence — "research preview" is the branding mechanism that re-attaches a stage-label to a shipped artifact
• Claude Design — Jenny's "design process is dead" thesis that Ambrosino qualifies with stage-awareness
• Compounding Loop Optimization — the speed that produces polished explorations fast enough to trigger the over-anchoring problem
• Review as the Control Point — the same severed signal at the code-review layer: surface plausibility (clean, idiomatic AI code) "lowers the reviewer's guard," so polish reads as a safety signal it no longer earns — a defect dressed as correct code clears faster because it's scrutinized less

Open Questions#

• If the medium no longer signals stage, what does — is explicit human labeling ("this is exploration") the only mechanism, or can tooling re-attach the signal (e.g. a visible "exploration / preview / prod" marker on every build)?
• Does over-anchoring get worse as builds get more polished, or does everyone eventually recalibrate and learn to discount fidelity entirely?

Sources#

• OpenAI Codex lead on the new shape of product work — Ambrosino: "the medium implied… where in the process something was… now those are divorced"; "can we release this now?" as the over-anchoring failure