C.W.K.
Stream
Lesson 04 of 04 · published

Two Modes, One Truth

~10 min · simple-verbose, one-calculation-path, progressive-disclosure, invariant

Level 0Open Gate
0 XP0/36 lessons0/12 achievements
0/100 XP to next level100 XP to go0% complete
"Beginners and experts should see the same numbers. Only the amount of explanation changes."

The default is quiet

Keep opens in Simple mode: the restrained, low-noise surface with just the essentials. For anyone who wants more, there's Verbose mode — but here's the crucial design decision. Verbose is not a second UI, a power-user dashboard, or a different set of features. It's a semantic help layer over the exact same product: every visible component gains a plain-language definition, an explanation of what it does, and why an action matters. The stored mode changes explanation density only. It never changes a single calculation or a single stored value.

Why 'one calculation path' is the whole point

The tempting way to build a beginner mode and an expert mode is two code paths — a simplified computation for novices, the "real" one for pros. That's a trap that guarantees drift: the two paths diverge, a bug fix lands in one and not the other, and eventually Simple and Verbose disagree about what the portfolio is worth. Keep forbids this. There is one calculation path and one mutation path. Simple and Verbose are two views of identical numbers. A beginner and an expert looking at the same portfolio see the same total, down to the cent — one of them just also sees a sentence explaining what "cost basis" means.

Explanation is a layer, not a fork. When you offer 'simple' and 'advanced' experiences, the difference must be in what you explain, never in what you compute. The moment the two modes run different math, you have two products that will drift apart and eventually contradict each other in front of the user.

Progressive disclosure done honestly

This is progressive disclosure with integrity. Simple mode isn't lying by omission — it's showing the true numbers with less commentary. Verbose mode isn't unlocking hidden data — it's adding definitions around the same data. Nobody is protected from the truth of their own portfolio in Simple mode, and nobody gets secret extra numbers in Verbose. The information is constant; only the scaffolding around it flexes to match how much the reader wants explained.

The test for a real 'help mode': switch it on and off and diff the numbers. If any value, total, or calculation changes, you built two products, not one product with two explanation densities. Only the words should change — never the math.
This lowers the trigger too. A single, honest, well-explained number is calmer than a wall of unexplained jargon. Verbose mode isn't more intense — it's more reassuring, because it removes the anxiety of not understanding what you're looking at. Clarity is part of calm.

Code

Mode changes prose, never the number·typescript
// ONE calculation, shared by both modes.
const total = computePortfolioTotal(owner, asOf);   // identical everywhere

// The mode only decides how much explanation wraps the same value.
function present(total: number, mode: "simple" | "verbose") {
  const value = format(total);                       // SAME in both modes
  if (mode === "simple") return { value };
  return {
    value,                                            // <- unchanged
    definition: "Total = stored cash + market value of all positions.",
    why: "This is a snapshot at the last completed close, not a live figure.",
  };
}
// If `value` ever differed by mode, that would be the bug this design forbids.

External links

Exercise

Pick an app with a 'basic' and 'advanced' mode (or 'lite' vs 'pro'). Investigate: do the two modes show the same underlying numbers with different explanation, or do they actually compute or reveal different things? If they diverge, describe the drift risk. Then sketch how you'd refactor it into one calculation path with a pure explanation layer on top.
Hint
Ask 'if I toggle the mode, could a number change?' If yes, the modes are forks and will eventually contradict each other. A true help layer is provably safe: it can add words but is structurally incapable of touching a computed value.

Progress

Progress is local-only — sign in to sync across devices.
Spotted a bug or have feedback on this page?Report an Issue

Comments 0

🔔 Reply notifications (sign in)
Sign inPlease sign in to comment.

No comments yet — be the first.