skip to content

Why does a shared-editor round penalize a hand-waved step that a whiteboard accepts?

level: middleimportance: should knowfreq 40%

answer

  1. ask what the medium makes possible
  2. the machine was sitting right there
  3. an elided step is an unchecked claim
  4. cost of certainty collapsed in the editor
  5. elide only what the room cannot verify

basics

~20 s

The medium changes what an unverified claim costs. At a board nobody can run anything, so intent is the deliverable; in a live editor an elided step reads as a check you chose not to make.

solid answer

~50 s

Interviewers grade against the affordances of the room. Writing `... then drop the SKUs whose net quantity is at or below zero` on a board is legitimate compression: the interviewer sees the shape of the filter, the cost is unchanged, and nothing in the room could have confirmed the line anyway, so they judge whether you know what belongs there. Type the same ellipsis into a shared editor and the calculus flips — a working filter is three lines and running it costs seconds, so leaving it unwritten is a skipped verification, not compression. The flag is rarely about the missing lines; it is about the inference that someone who skips a cheap check here skips cheap checks generally. The rule: elide only what the room cannot verify, and when you defer something in an executable round, say so and close it before calling the solution finished.

code

pseudocode · 10 lines
pseudocode
totals = empty map
for i in 0..length(records)-1
    sku = records[i].sku
    qty = records[i].quantity
    if sku present in totals
        totals[sku] = totals[sku] + qty
    else
        totals[sku] = qty
// ... then drop every sku whose total is at or below zero
return totals

go deeper

for a junior

Recall that an unwritten step is judged by how easily the room could have checked it. At a board, say aloud what belongs in the gap; in a live editor, write it and run it instead of describing it.

for a middle

Explain the mechanism, not just the rule: the interviewer measures your claim against the cheapest proof available in that room. Be able to say which elisions stay cheap and which become expensive once execution is on the table.

for a senior

Demonstrate disciplined deferral. Announce a stub, keep the program runnable, and close it before declaring finished — then run the exact case the stub was hiding, so the interviewer sees verification as your default rather than a prompt-driven step.

for a principal

Own the read that interviewers are really taking: how someone treats a cheap check under time pressure predicts how they treat cheap checks in a codebase. Be ready to argue what that signal is worth and where it over-penalises fast, correct thinkers.

## Affordances decide what hand-waving costs Consider a small aggregation over a restock feed: records carrying a SKU key and a quantity, some negative because they are returns. You want the net quantity per SKU, with the net-zero-or-below SKUs dropped. The skeleton is a keyed accumulation followed by a filter, and the filter is the part candidates habitually compress into a phrase. At a whiteboard, that compression is fine and often welcome. The reason is mechanical, not generous: **the room has no way to check the filter either way.** With no execution available, the interviewer is inferring your competence from what you say and how your reasoning holds together. `... then drop the SKUs whose net is at or below zero` tells them you know the filter exists, where it sits relative to the accumulation, that it does not change the linear cost, and that the ordering matters — filter before the accumulation finishes and you would drop a SKU that a later return, or a later restock, would have rescued. Those are the things the format can grade, and you supplied them. Writing the three lines out adds nothing verifiable, and it burns board space that your invariant and your trace need more. ### What changes when the room can execute In a shared-editor or IDE round, everything about that same ellipsis changes, because the cost of certainty collapsed. The filter is a few lines. Running the program on a feed containing one SKU that nets to zero costs seconds. When verification is nearly free and you decline it, the interviewer is no longer looking at a compression; they are looking at a **choice not to check**, and the inference they draw generalises well beyond this exercise. Their honest read is: this is what code review with this person will feel like. The severity also tracks how load-bearing the elision is. Eliding a step that is genuinely mechanical and clearly specified — reading input in an agreed format, say — draws little. Eliding the step where the actual subtlety lives is expensive, because it removes the one part of the solution the interviewer most wanted to watch you get right. In our example the subtlety is exactly the boundary: is *at or below zero* the rule, or *below zero*? A SKU that nets to precisely zero is the discriminating case, and it lives inside the ellipsis. ### The asymmetry stated plainly - **Board:** unverifiable by anyone in the room. Stated intent is the maximum available evidence, so stated intent is accepted. The failure mode is not eliding — it is eliding *without saying what belongs there*, which leaves nothing to grade at all. - **Editor:** verifiable by anyone in the room. Stated intent is now the *minimum*, and executed behaviour is the available evidence. The failure mode is claiming what you could have shown. This is why the identical sentence draws a nod in one room and a note in the other. Nothing about the sentence changed; the cheapest available proof did. ### How to elide well in an executable round Sometimes you genuinely should defer. The technique that keeps it from reading as avoidance has three parts: 1. **Name it as a deferral, not a completion.** Say that you are stubbing the filter to get the accumulation running end to end first, and that you will return to it. An announced stub is a plan; a silent stub is a gap. 2. **Leave the shape in place.** A stub that returns everything unfiltered, with the intended predicate written as a comment, keeps the program runnable and makes the return trip trivial. 3. **Actually return, before you call it finished.** The deferral is only credited if it closes. Finish the filter, then run the net-zero case — the very case the ellipsis was hiding — and let the interviewer watch it pass. Done this way, the deferral becomes evidence of sequencing judgment instead of evidence of avoidance. ### The misconception to unlearn *Hand-waving is a style preference, and interviewers who flag it are being pedantic.* It is not style; it is a signal about verification habits, read through the medium's affordances. The same candidate, saying the same words, is measured against a different cheapest-available-proof in each room. Track what the room can prove for you, and never claim something the room would have proved in seconds.

  • Does the same logic mean an editor round should never contain a stub?
    No — deferring is fine when it is announced and closed. Say you are stubbing the filter so the accumulation can run end to end, keep the program executable with the predicate noted, then come back and run the net-zero case before calling it finished. An announced stub reads as sequencing judgment; a silent one reads as avoidance.
  • Which elisions are expensive, and which are cheap?
    Cost tracks where the subtlety lives. Eliding fully mechanical work draws little. Eliding the step containing the discriminating boundary — whether a SKU netting exactly zero is dropped or kept — is expensive, because it removes the one moment the interviewer most wanted to watch. If a case would distinguish two plausible readings, that step is not elidable.
  • How should a candidate elide at a whiteboard so it still reads as strong?
    State what belongs in the gap, where it sits relative to the rest, and what it costs. The board failure is not compression but silent compression: an ellipsis with no spoken content leaves the interviewer nothing to grade. Say the predicate aloud, note that it runs after the accumulation completes and leaves the linear bound unchanged, and the gap becomes deliberate.

saying these in an interview costs you the question

  • Treats hand-waving as a pedantic style complaint
  • Leaves the subtle step unwritten in an executable round
  • Silent ellipsis with no spoken content at a board
  • Announces a stub and never returns to it
  • Claims behaviour the room could have confirmed in seconds

context

resolving links…