skip to content

Triage cannot settle whether an unfamiliar requirement is easy or hard inside the spike's timebox — what do you commit to?

level: principalimportance: nice to knowfreq 30%

answer

  1. timebox the classification, not the decision
  2. the two wrong calls cost differently
  3. hard-called-routine surfaces late
  4. boundary, guard, named risk
  5. unresolved must be speakable

basics

~20 s

Commit to the reversible option: build behind a boundary, guard the input sizes you can defend, and record the unresolved question where the requirement lives. The two wrong calls cost differently, and the expensive one surfaces late, under real data.

solid answer

~40 s

I time-box the triage, then decide on cost asymmetry rather than on a guess. Assuming **routine** when the problem is hard fails late — small test data runs fast, and the cliff appears in production, after the schedule is committed. Assuming **hard** when it is routine fails quietly — you ship approximate answers where an exact result was free, and nobody revisits it. So I commit to the option that keeps both doors open: a boundary the solver sits behind, an explicit guard on input size that fails loudly, representative-data measurement to locate the real cliff, and the unresolved question written down as a risk with a named owner. What I refuse to do is let "unresolved" quietly become "routine" inside an estimate.

go deeper

for a junior

Notice that a correct program can still be the wrong plan. If you cannot tell how the cost grows, say so rather than letting a fast run on sample data settle the question for you.

for a middle

Practise the cheap experiments: an exhaustive oracle on small inputs and a growth curve over several sizes tell you more than a debate about which known problem it resembles.

for a senior

Commit to the reversible design — a boundary, an enforced size guard, measured limits — and make sure the unresolved question is written where the requirement lives rather than in a thread.

for a principal

Own the asymmetry of the two wrong calls and the culture around it: make an unresolved verdict a normal thing to report, and hold the line against reflexive approximation that quietly gives away exact answers.

## Triage is timeboxed on purpose Classifying an unfamiliar requirement can consume an afternoon or a fortnight, and the value curve is steep at the start and flat afterwards. The first pass buys most of what is available: a skeleton, a candidate match, the restrictions the requirement might carry. After that you are doing research, and research is a decision a lead makes deliberately, not something a spike drifts into. So the real question is not "how do I finish the triage" but "what do I commit to with an unfinished one". ## The two wrong calls are not symmetric | Wrong call | How it fails | When it is discovered | Cost to reverse | |---|---|---|---| | Called routine, actually hard | The method stops finishing as inputs grow | Late, under real data, after commitments | High: rewrite plus a schedule already promised | | Called hard, actually routine | Approximate answers shipped where exact ones were available | Often never | Low technically, but the quality loss persists unnoticed | The first failure is louder and more expensive, which is why an unresolved triage must never default to it — and defaulting is exactly what happens when nobody says the word *unresolved*, because estimates are written as though the work were ordinary. The second failure is cheaper but more insidious: an approximation that nobody revisits becomes the permanent behaviour of the product, and the free exact answer is never reclaimed. ## Buying evidence cheaply inside the box 1. **Build a brute-force oracle.** An exhaustive method on small instances is quick to write, and comparing it against a candidate approach tells you whether the approach is even correct before you argue about its cost. 2. **Measure the growth, not the runtime.** Run representative data at several sizes and look at the shape of the curve. A cliff between two adjacent sizes is worth more than any classification argument in the room. 3. **Ask the requirement, not the algorithm.** Does the business need the optimum, or a defensible answer produced consistently? A large share of triages dissolve here, because the hard version was never required. 4. **Hunt one restriction.** Ask whether the input is always tree-shaped, always two-valued, always small in the one dimension that matters — and whether that is guaranteed or merely current. ## What to commit to when it stays open - **A boundary.** Put the solver behind an interface so the implementation can be replaced without touching callers. This is the cheapest insurance available and it costs nothing if the verdict turns out to be routine. - **A guard, not a hope.** Reject inputs beyond the size you have measured, with a clear error. An unenforced assumption disappears at the next requirement change. - **A named risk.** Record what is unresolved, what would settle it, and who owns settling it. An unowned risk is a rediscovery. - **A staged commitment.** Promise the sizes you have evidence for, and treat the larger ones as a separate decision with its own trigger. ## The part a lead actually owns Engineers can classify; only a lead can decide how much uncertainty the plan carries and who is told. That means making "unresolved" a legitimate, speakable outcome in your team rather than an admission of failure — because the moment it is embarrassing, it stops being reported, and the expensive failure mode becomes the default. It also means resisting the opposite reflex: a team that reaches for approximation at the first sign of combinatorics gives away exact answers that were free, and nobody ever files a ticket about a result that is merely slightly worse than it needed to be.

  • Why does the hard-problem-called-routine mistake almost always escape review?
    Because it is a growth defect, not a logic defect. The code is correct and the test data is small, so everything passes; the cost only appears at production scale, by which time the design and the schedule are both committed.
  • What does a brute-force oracle give you that an argument about classification does not?
    Ground truth on small instances. It tells you whether a candidate method is correct at all, exposes where a heuristic diverges from the optimum, and gives you a curve of real measurements to show stakeholders — evidence that survives disagreement about which known problem the requirement resembles.
  • How do you keep a team from reaching for approximation too early?
    Require the triage to name the exact method it is giving up and the size at which it stops being affordable. Once that sentence has to be written, most premature approximations do not survive it, because the exact method turns out to be perfectly comfortable at the sizes in play.

saying these in an interview costs you the question

  • Lets an unresolved triage become an ordinary estimate by default
  • Extends the spike indefinitely rather than committing to anything
  • Ships an approximation without naming the exact method being given up
  • Treats small test data passing as evidence about growth
  • Records the uncertainty in a chat message with no owner