LLenny's Podcast
← All frameworks
StrategyMax Schoening (Head of Product, Notion)

Obviously Good, Then Incremental Correctness

Only make obviously good stuff, ship it in iterations, then reconcile the sprawl back to a naked robotic core.

Difficulty
Advanced
Time to result
~months to results
Steps
3
Confidence
85%

Schoening's shipping doctrine has three moves. First, a quality bar: only make 'obviously good' stuff — the kind of thing nobody argued about when they first saw the iPhone or ChatGPT. Second, a cadence: 'incremental correctness' — get really good at iterating and increase shots on goal rather than hiding in a cave until perfect. Third, a cleanup discipline: after letting several ideas grow in parallel, do the hard work of consolidating them back into the naked robotic core, even if it delays the next feature. It balances speed against the quality erosion that comes from feature sprawl.

Origin

Schoening's own values at Notion, expressed via internal 'obviously good' stickers and the 'incremental correctness' core value; he notes the labs (and even Claude's desktop app with three co-work tabs) suffer the same sprawl problem.

Core principles

  • 01The bar is 'obviously good' — you know it when you see it (iPhone, ChatGPT)
  • 02Incremental correctness: get really, really good at iterating
  • 03Increase shots on goal rather than perfecting in isolation
  • 04Let multiple ideas grow, then consolidate to the naked robotic core
  • 05Reconciling primitives may delay the next ship — accept that

How to run it

  1. 1

    Set the bar at 'obviously good'

    Judge work against whether it is obviously good — the kind of thing nobody argued about when they first saw the iPhone or when ChatGPT first came out. If it isn't obviously good, it isn't ready to be the bar.

    Pro tip 'You know it when you see it' is a feature, not a bug — use collective recognition as the gate.

    Watch out Don't retreat into a cave in isolation until it's obviously good; that's the trap teams fall into with this bar.

  2. 2

    Ship via incremental correctness

    Iterate publicly and get really good at iterating, increasing shots on goal. Since exploration is now cheaper, more shots are affordable — use them instead of one perfect swing.

    Pro tip Getting roasted by customers for having several competing primitives is acceptable while you learn how they're used.

    Watch out Just shipping feature after feature doesn't work — cadence without the cleanup step produces sprawl.

  3. 3

    Reconcile primitives to the naked robotic core

    After letting several ideas grow (e.g. six automation primitives in Notion), do the hard work of consolidating them into the core simple thing that should outlive the other evolutionary branches — even if it delays the next feature.

    Pro tip Someone has to sit down and figure out which single idea is the core; budget for that reconciliation explicitly.

    Watch out Skipping consolidation leaves you with six overlapping primitives (or three mystery co-work tabs) that confuse users and erode quality.

In the wild

Notion's six automation primitives

Notion deliberately let a bunch of different automation ideas grow — ending up with around six automation primitives including the agents — and gets roasted by customers for it. Schoening embraces the growth phase but insists on the hard follow-up: consolidating back into the naked robotic core of the idea.

Ideas are explored broadly, then reconciled into a simpler core that outlives the branches, at the cost of a slightly delayed next ship.

The 'obviously good' sticker

Notion has 'obviously good' stickers encoding the value of only making obviously good stuff; Schoening points to the first iPhone and the first ChatGPT as things nobody argued were obviously good.

A shared, recognizable quality bar the team can invoke without lengthy debate.

Common mistakes

Hiding in the cave until perfect

Interpreting 'obviously good' as license to work in isolation until the thing is perfect. Schoening pairs the bar with incremental correctness precisely to avoid this.

Letting primitives sprawl without reconciling

Allowing many overlapping primitives to grow and never consolidating them into a naked robotic core confuses users and degrades software quality — the hard reconciliation work is the point.

Is it for you?

Best for

Product and eng leaders balancing shipping velocity against quality and coherence in a fast-moving AI product org

Not ideal for

Early exploration where premature consolidation would kill useful variety, or tiny teams without the sprawl problem to reconcile

From the transcript

let's just only make obviously good stuff

55:00

incremental correctness, which is sort of, uh, iterate, get really, really good at iterating

55:30

naked robotic core of that idea

56:00

From the episode

Why cultivating agency matters more than cultivating skills in the AI era

Max Schoening (Head of Product, Notion)