Extensibility

interface ExportFormat {
  header(cols: string[]): string
  row(values: string[]): string
  footer(): string
}

const FORMATS: Record<string, ExportFormat> = { csv: new CsvFormat() }

export function runExport(name: string, rows: Row[]) {
  const f = FORMATS[name] ?? fail(`unknown format ${name}`)
  // ... drive f.header / f.row / f.footer
}

// One implementation. The row-at-a-time shape is a guess,
// and JSON, XLSX and PDF each break it differently.

// export/select.ts  — what goes in the file
export function selectRows(f: Filters): Row[] { /* ... */ }

// export/csv.ts     — how it is encoded
export function toCsv(rows: Row[]): Buffer { /* ... */ }

// export/job.ts
const rows = selectRows(filters)
return toCsv(rows)

// No interface, no registry. Selection and encoding are
// separated because they have different reasons to change
// TODAY — not because a second format might appear.

Both versions cost about the same to write, and they differ in what they commit to. The second commits to a split justified by present reasons to change: the columns in an export move when the product moves, and the encoding moves when a format spec moves. The first additionally commits to a decomposition of formats derived from one sample, and that commitment has to be undone before the second format can be added — so the guess makes the change it was built for more expensive rather than less.

1. 1
   Build the first case directly

   One function, no interface, no registry. Separate the parts that have different reasons to change today.

   fails by Adding the interface here, where the only available evidence is the case that did not need one.

2. 2
   Write down the axis you suspect

   A line in a decision record: "if a second export format appears, extract an encoder seam". Costs a minute and makes the guess reviewable.

   fails by Keeping it in your head, so the next person either rebuilds the reasoning or does the opposite.

3. 3
   Wait for a real second case

   A requirement with a requester and a date, not a hypothetical.

   fails by Counting an imagined case as the second one, which is how the rule gets quietly cancelled.

4. 4
   Implement the second case directly too

   Duplicate on purpose. Now both shapes are visible side by side and the differences are data rather than speculation.

   fails by Abstracting during the second implementation, before the differences have surfaced.

5. 5
   Compare, then extract

   Extract the shape the two implementations actually share, and only that shape.

   fails by Extracting a superset "while we are in here", which reintroduces the guess at the point it could have been avoided.

6. 6
   Delete the duplication

   Migrate both onto the extracted seam and remove the copies.

   fails by Stopping after the extraction, leaving the seam and both copies live — the most common way this loop fails (Incremental Migration).

The loop is asymmetric on purpose: building early costs an interface you must undo, while building late costs an extraction done with full information. Those are not the same size of mistake, which is the entire case for waiting.