Lesson 0037 · Master Designer · Module 3

Correctness vs Delivery Speed

Right or now — the oldest trade. The master's resolution: classify the change as reversible or irreversible. Reversible changes may go fast; irreversible ones can't afford to be wrong.

Mission tie-in: the third Evolution Trade-Off — where Phase I's fail-fast and Phase II's tests meet the real pressure of shipping.

Knowledge: reversible or irreversible?

Every change has a failure cost: what happens when it's wrong? Classify:

Reversible — wrong means a rollback, a revert, a fix-forward. The blast radius is a deploy cycle. These can ship fast: tests cover the essentials, the team watches the metrics, and the correction loop is cheap.
Irreversible — wrong means money lost, records corrupted, legal exposure, data destroyed, trust burned. These ship with the full apparatus: invariants (lesson 0011), fail-fast (lesson 0014), tests around the domain rules, and a slow, staged rollout (lesson 0035).

The trick that collapses the trade: tests are the speed technology. A suite that locks the domain rules (characterization tests from lesson 0005, TDD for new rules) makes fast shipping safe — the team's speed comes from the safety net, not from skipping it.

# reversible: a display change — ship fast, watch the metric
def render_header(title: str) -> str:      # tests: the essentials
    ...

# irreversible: a charge — ship with the apparatus
class ChargeService:
    def charge(self, amount: Money, token: str) -> str:
        charge_id = self._gateway.charge(amount, token)   # idempotency key
        self._ledger.record(charge_id, amount)            # invariants, fail-fast
        return charge_id

The discipline is naming the class out loud: before cutting the corner, say "this is reversible — a rollback fixes it" or "this is irreversible — it needs the apparatus." The silent version is where the trade goes wrong: irreversible changes shipped at reversible speed.

† AI accelerates both sides: it ships fast code faster, and fast wrong code faster too. The classification is exactly the judgment AI can't provide — state the class in the prompt (lesson 0010) and let the generated tests match it.

Field notes · classify, then choose the apparatus

The change	Class	What the class earns it
a colour, a label, a copy tweak	reversible	Ship it; watch the metric for an hour.
an outbound email to every user	irreversible — you cannot unsend	A dry run, one small cohort, a kill switch.
a migration that drops a column	irreversible	A backup, expand/contract (lesson 0035), a rehearsed rollback.
a pricing rule change	irreversible — the money already moved	Tests on the rule, staged rollout, a reconciliation report.
an endpoint nobody calls yet	reversible	Ship it; the users are the flag, not the code.

Skill: which class is this change?

A button color change gone wrong costs a revert. It is:

A charging flow whose error corrupts the ledger is:

Tests make fast shipping safe because they:

Practice on your own code

Take your last three shipped changes. Classify each: reversible or irreversible? For any that shipped fast without the apparatus while being irreversible — name the loan you took (and the next lesson's ledger will make it honest).

Reveal: a classification audit

Three changes: a navbar tweak (reversible — shipped fast, correct call); a new discount rule (irreversible — shipped with tests, correct call); a migration that dropped a column (irreversible — shipped without a backup rollback path; the loan: recovery took a day of manual repair). The audit names the loan; lesson 0038 tracks it.

Your win

You can classify any change by its failure cost, apply the apparatus only where the class demands it, and use tests as the speed technology instead of the speed tax.

Read and watch deeper

Test-Driven Development by Example, Beck — the discipline that makes speed safe: tests as the design and delivery instrument.
Working Effectively with Legacy Code, Feathers — ch. 1–2: characterization tests as the bridge into changes you can't fully verify.
A Philosophy of Software Design, Ousterhout — ch. 10 "Define Errors Out of Existence": design the irreversible class so it can't go wrong.
Watch: ArjanCodes YouTube — search "testing" or "TDD".
Next: lesson 0038 — the final trade-off.
Reference: Trade-offs — correctness vs delivery speed; Patterns — characterization test.

Classify your pending changes with your agent-teacher before you start — the out-loud version is the discipline.

Mark lesson complete