skip to content

A spaced re-attempt of a previously failed problem fails the same way - what does that tell you?

level: seniorimportance: nice to knowfreq 30%

answer

  1. the second failure carries more information
  2. it is a verdict on your remedy
  3. ask where the attempt stopped
  4. naming, deriving, or coding - three causes
  5. shorten the interval, change the remedy

basics

~20 s

A repeat failure is better information than the first: it proves your remedy missed the cause. Diagnose by where the attempt broke - naming the approach, deriving it, or coding it - then change the remedy, not the interval.

solid answer

~50 s

The first failure tells you a gap exists; a second failure, days later and cold, tells you what kind of gap and that your fix missed it. I locate the breakdown precisely. If I could not name the approach at all, it is a retrieval gap - the trigger was never encoded, so re-reading the solution again will not help, and I need the recognition cue written in my own words plus other instances of the same pattern. If I named the approach but could not reconstruct the invariant, it is an understanding gap, and I rebuild from brute force rather than from memory. If I built it and hit the same boundary defect, it is mechanical, and the fix is a pre-submit routine, not more theory. The interval also shortens rather than lengthens: a failed re-attempt means the item was not consolidated, so it comes back sooner.

go deeper

for a junior

Be ready to say why you would try a failed problem again days later with nothing in front of you, and that failing again is information about your fix rather than a verdict about your ability.

for a middle

Explain how to locate the breakdown - could not name the approach, named it but could not derive it, or built it and repeated the same mechanical defect - and why each of the three calls for a different remedy.

for a senior

Show that you treat a repeat failure as a verdict on your own remedy: change the remedy, shorten the interval, and recognise that a fluent re-solve of the same problem may be recall of code rather than an available technique.

for a principal

Own the calibration question: how much of a reviewed backlog is actually verified, what evidence you would accept before calling a weakness closed, and how you keep a verification queue from crowding out everything else.

## The second failure is the informative one A first failure tells you almost nothing beyond "there is a gap here". You did not solve it; there are half a dozen possible reasons, and at that moment you cannot distinguish them, because your judgement is contaminated by having just read the solution. A cold re-attempt days or weeks later is a controlled measurement: the specifics have faded, the remedy you applied has had time to work, and the result is a verdict on the remedy rather than on the original attempt. Which is why a repeat failure is disappointing and valuable in the same breath - it is the only cheap way to find out that your fix was aimed at the wrong thing. The wrong response is to conclude that the problem is "hard for me" and lengthen the interval or drop it. That converts a measurement into a verdict about yourself and discards the diagnosis. ## Locate the breakdown before choosing a remedy The useful question is not *did I fail* but *where did the attempt stop*. Three places, three different causes. **You could not name an approach.** Nothing came back - not the technique, not even the family. This is a retrieval failure: whatever you did after the first attempt encoded a solution, not a cue. The remedy is not to re-read the solution a third time; it is to write the recognition trigger explicitly - the property of the input that should make this technique come to mind - and then to meet the same trigger on several different problems, so the association attaches to the property rather than to one story. **You named the approach but could not build it.** You knew it was the right family and stalled on the invariant, the update order, or what the state should hold. That is an understanding gap wearing the costume of a memory gap. The remedy is to derive rather than recall: restate the brute force, name the repeated work, and reconstruct the improvement from that, so the details follow from the reasoning instead of from memory. **You built it and hit the same defect as last time.** The idea arrived, the structure was right, and the same boundary or initialisation went wrong again. That is mechanical, and it responds to a procedure, not to more study: enumerate the degenerate inputs before writing code, run the smallest and largest legal input by hand, check the interval convention explicitly. This is also the diagnosis people most often mis-file as "I don't understand this pattern", which sends them re-reading theory to fix a checklist problem. ## When the repeat attempt succeeds, be suspicious anyway The complementary trap: a re-attempt that succeeds because you remembered the shape of the code rather than because the technique is available. The tell is that you produced the solution without ever re-deriving why it works, or that you cannot state the trigger. Treat that as unresolved and test transfer instead - a different problem the same trigger should fire on. Passing the identical problem again mainly proves that you have seen it twice. ## What the pattern of repeat failures says about the log A senior read goes one level up. If several spaced re-attempts fail, the entries you had marked as resolved were never verified, and the same is probably true of the ones you have not re-attempted yet. That reframes the log: entries move from *reviewed* to *verified* only when a cold attempt succeeds, and until then your sense of how much you have learned is inflated by an unknown factor. Practically, that means keeping a small verification queue rather than trusting a large reviewed pile, and it means resisting the urge to declare a category closed on the strength of a drill block alone. ## Scheduling after a failure The interval should shorten, not lengthen. A failed re-attempt is evidence that the item was not consolidated, so the next contact comes sooner - and, importantly, only after the remedy has changed. Repeating the same interval with the same remedy is running the same experiment and expecting a different reading. Once it succeeds cold, the interval can stretch again, and the item can graduate to a transfer test on a sibling problem rather than another attempt at the same one. ## The cost side Re-attempts compete with new problems for a fixed number of hours, and they feel less productive because you are not adding to any count. The honest framing is that a failed re-attempt just told you that some fraction of your earlier practice did not stick - which is information you were going to receive eventually, either now for the price of forty minutes or later in a room with an interviewer in it.

  • The re-attempt succeeded. How do you know it was not just memory of the code?
    Check whether you re-derived anything. If you can state the trigger and explain why the invariant holds, the technique is probably available. If it came out fluently but you cannot say what property of the input made it apply, treat it as unverified and test transfer - attempt a different problem the same trigger should fire on. Re-passing the identical problem mostly proves you have seen it twice.
  • Doesn't spending hours on re-attempts cost you the new problems you would otherwise see?
    It does, and that is the point of measuring rather than guessing. A failed re-attempt reveals that a slice of earlier practice did not stick, which is a strictly better time to find out than during a real loop. The balance I keep is a small verification queue of items that have never survived a cold attempt, not a growing pile of everything I have ever reviewed.
  • After a repeat failure, how long until the next attempt?
    Sooner than last time, and only after the remedy changes. A failure means the item was not consolidated, so the next contact moves closer rather than further away. Repeating the original interval with the original remedy re-runs an experiment whose result you already have. Once it passes cold, the interval can stretch again and the next test should be a sibling problem rather than the same one.

saying these in an interview costs you the question

  • Failing twice means the problem is beyond me
  • Just re-read the solution once more
  • Lengthen the interval and try again later
  • Passing the same problem again proves it is learned
  • All repeat failures have the same cause

context