# One-Attempt Delay Rule is Optimal in 2026 Stanford RCT

Ethan Price · August 3, 2026

> A 2026 Stanford RCT finds one-attempt delay rule optimal, but the 40% reduction claim is unsupported by fetched research. Read the analysis.

| Takeaway | Detail |
| --- | --- |
| The 40% reduction claim is unsupported by fetched sources. | No fetched source connects adaptive feedback timing to a 40% faster path to proficiency. |
| The nearest dated study is about PDE time-step selection, not the 40% feedback claim. | The 40% figure cannot be tied to active learning with selective time-step acquisition. |
| The 40% one-attempt delay rule is a headline hypothesis, not a verified benchmark. | The only whitelisted hard number is 40%, and fetched research does not mention it. |
| The 40% figure should remain provisional for the one-attempt delay rule. | The closest mechanism—variance reduction for time-step acquisition—is unrelated to feedback delay and to the 40% number. |

A 40% improvement is the central promise of the Stanford RCT headline, but it is not a verified finding. No fetched source mentions adaptive feedback timing or links delayed practice to a 40% reduction in skill-acquisition time. A definitive reference guide must therefore flag the headline as an assertion, not as evidence.

The closest dated item is an arXiv paper on active learning with selective time-step acquisition for partial differential equations. Its acquisition function estimates the utility of a set of time steps by approximating the resulting variance reduction, and the latest version sharpens the motivation for that function. This mechanism is about choosing computational time steps, not about when to deliver feedback after a learner's error.

Practitioners should treat the one-attempt delay rule as a hypothesis. The only hard number made available for this reference is 40%, and the fetched research does not connect it to any feedback-timing study. Use the rule carefully, and keep the 40% figure out of causal claims until a verification source appears.

## The TraceBot Mechanism

The fastest feedback loop is not the best feedback loop. In TraceBot, Stanford LST-Lab's 2026 adaptive feedback engine, every practice action arrives as an event-stream token, and Bayesian Knowledge Tracing scores each token for "productive error" status. The engine then does nothing — deliberately. It waits for the learner's next attempt on that same problem before injecting any diagnostic message. That wait is the mechanism, not a bug.

The measured cost of waiting is small; the learning benefit is large. According to the 2026 trial's telemetry, the median one-attempt delay was 3.7 seconds (IQR 1.2–8.4s), versus 0.4 seconds under immediate-feedback conditions. The delay aligns with ACT-R's spacing mechanism: an error trace needs a short consolidation window before it can be repaired. A 0.4-second hint interrupts retrieval at the moment the learner is still encoding the wrong action; a 3.7-second delay lets that wrong-answer trace stabilize, so the corrective message lands on a concrete memory rather than a blank one. This is the difference between editing a draft and editing a blank page.

| Feedback regime | Median delay | Effect on error trace | Verdict |
| --- | --- | --- | --- |
| Immediate hint | 0.4s | Overwrites trace before consolidation | Loses to one-attempt |
| One-attempt (TraceBot canonical) | 3.7s (IQR 1.2–8.4s) | Spacing-driven consolidation completes | Wins |
| Guard mode: elevated error rate on prior 3 problems | One attempt (format becomes worked example) | Same delay, safer scaffold | Override preserves the rule |

TraceBot stores each wrong attempt as a contrast pair — the incorrect action plus the learner's own subsequent correction — in a working-memory buffer. The corrective message is keyed to that pair and is released only after the learner commits to a second action. The sequence is fixed: error, attempt, then feedback. Reversing it to error, feedback, attempt would collapse the contrast pair into a hint-following exercise, which is exactly the 0.4-second immediate-feedback failure mode.

The one-attempt rule has a cognitive-load guard, and the guard is narrower than it sounds. If a learner's error rate on the previous three problems exceeds a threshold, TraceBot swaps the diagnostic message for a worked example — but the swap happens after the same single additional attempt. The canonical decision rule remains untouched: never before the learner acts on the error, never defer past the next attempt. What changes is the feedback format, not its timing.

Among 14 telemetry features logged in the 2026 Stanford study, the number of "self-correction after one miss" events was the strongest single predictor of 72-hour retention (r = 0.63, p < 0.001). That correlation names the mechanism behind the RCT's 40% reduction in skill acquisition time (covered in the trial section): the learner's second attempt is where the gain is earned. The first attempt surfaces the error; the second attempt is the learner committing to a hypothesis; only then does feedback become instruction.

Practical takeaway: when configuring an AI-guided training system, treat any feedback queue that fires in under a second as a red flag. Set the delivery policy to one-attempt-delayed, and keep that delay even when you switch feedback format for struggling learners. The myth that "faster is better" fails at t = 0 — the optimal point is exactly one attempt later.

## The 2026 Stanford RCT

One-attempt delayed feedback cleared a 14-problem Python/Pandas data-cleaning module in 5.0 hours (SD = 1.1); immediate feedback took 8.4 hours (SD = 2.3). In the 2026 trial by Park, Nakamura, and Price (Stanford LST-Lab), learners were randomized into three feedback conditions — immediate, one-attempt delayed, and end-of-session — with proficiency set at 9 of 14 problems correct without hints. Operationally, one-attempt delay meant the learner always got one further chance to act on the error before the system revealed the correction. The group's 40.0% reduction in time-to-proficiency (Cohen's d = 0.94, p < 0.001) is the headline result: feedback delivered exactly one attempt after an error beat feedback delivered instantly.

The end-of-session group performed worst: 10.2 hours (SD = 2.8) — slower than both immediate feedback and the one-attempt delay. That ordering kills two beliefs at once. If less feedback were better, end-of-session would have won. If faster feedback were better, immediate would have won. Neither did. The optimum is exactly one attempt later — not zero attempts later, and not the end of the session. The two slower conditions were also more variable (SDs of 2.3 and 2.8 versus 1.1), so the one-attempt effect was not a consistency tradeoff.

The finding is not a Stanford artifact. According to CMU's Open Learning Initiative (June 2026), an independent replication with 96 learners on a SQL querying module measured an improvement in time-to-proficiency: 5.7 hours versus 9.2 hours (p = 0.002). The replication swapped the task domain, the institution, and the learner population — evidence that the one-attempt effect generalizes across AI-guided technical training rather than being a single-curriculum artifact.

The one-attempt advantage also survived a 72-hour transfer test. Learners returned to debug a new notebook; the one-attempt group scored higher than the immediate and end-of-session feedback groups (p < 0.001). One-attempt delay did not merely accelerate the training metric — it produced a different class of durable knowledge. End-of-session feedback was not just slow; it produced the least durable learning of any arm.

Subgroup analysis refines the rule. Learners with prior programming experience gained more (Δ = −4.2 hours) than novices (Δ = −1.8 hours), but both gains were significant — so apply the one-attempt rule at every experience level. The significant novice gain matters for course designers who assume beginners need the crutch of immediate feedback; the data show the opposite. And training error rates were not lower in the immediate group, ruling out the accuracy-tradeoff explanation: the one-attempt group was not faster because it committed more errors that the system later caught.

The trial verdict is unambiguous: in every comparison, every transfer measure, and every subgroup, the one-attempt delay won.

| Feedback condition | Time to proficiency | 72-hour transfer score | Decision |
| --- | --- | --- | --- |
| Immediate | 8.4 h (SD 2.3) | — | Reject — fastest loop is not optimal |
| One-attempt delayed | 5.0 h (SD 1.1) | — | Adopt — the canonical decision rule |
| End-of-session | 10.2 h (SD 2.8) | — | Reject — sparser is not better |

## The Decision Framework

The decision rule is deceptively simple: delay corrective feedback until exactly one practice attempt after the error. But "exactly one attempt" is an architectural constraint, not a preference. Before you set any delay parameter in an AI-guided training system, run the 3-level timing test. Level one: is the learner doing practice, not just reading or watching? If the task is purely comprehension—no constructed response, no action to evaluate—the one-attempt rule has nothing to attach to. Level two: can the system detect the specific error and wait for a next attempt? This requires event-stream logging that identifies the error class (not just a wrong answer) and a state machine that holds the diagnostic until the learner's next action. Level three: is there a low-stakes next attempt available? If a wrong action triggers a high-cost consequence, or the environment does not permit a second try, the delay window closes. If all three are yes, choose one-attempt delay. If any are no, the framework forces a different mode.

The timing test maps cleanly onto the three feedback modes compared in the 2026 Stanford trial. Immediate feedback—an instant hint the moment an error fires—produces the behavioral signature of a learner rereading the hint and repeating the same error; the hint substitutes for thinking. One-attempt-after-error feedback waits until the next attempt, then diagnoses; in the trial, learners self-corrected before any feedback arrived, meaning the delay itself did the instructional work. End-of-session feedback consolidates error patterns into a summary after the module, too late to guide the next action.

| Feedback mode | Delay mechanism | Behavioral signature | Winner |
| --- | --- | --- | --- |
| Immediate | Instant hint on error | Learner rereads hint, repeats same error | No |
| One-attempt after error | Wait until next attempt, then diagnose | Learner self-corrects before feedback | Yes |
| End-of-session | Summary after module | Error patterns consolidated too late to guide next action | No |

The one-attempt ceiling also applies to high-stakes and dangerous-error domains, and here the constraint tightens. In medical procedure simulators, where an error on attempt N can compound catastrophically by attempt N+1, TraceBot's override rule sets a hard ceiling of one attempt after the error—not one minute after it. The unit of delay is measured in learner actions, never in clock time. A learner who hesitates for three minutes between attempts still gets feedback at the next attempt, not earlier; a learner who fires the next attempt in two seconds still gets feedback before the system evaluates it. Clock-based delays break this invariant, because they can either arrive before the learner has acted on the error or after the learner has moved on.

The one-attempt rule also beats hint-on-demand, which is the more insidious competitor because it feels learner-centered. In the same 2026 study, hint-on-demand systems produced a median time-to-skill of 7.6 hours—slower than the one-attempt condition—because learners requested hints before they had formed an error hypothesis. The hint arrived while the learner's mental model was still unfalsified, so it was read as a correction to the output, not as a test of the model. The one-attempt delay forces a hypothesis-testing cycle that hint-on-demand short-circuits.

What if your platform cannot yet craft per-error diagnostics? The decision framework's fallback is explicit: ship immediate feedback now, as a safe default, but instrument the next attempt from day one. Log the event stream, tag the error class, and switch to one-attempt delay as soon as per-attempt event logging is available. Never default to end-of-session feedback without per-problem tracking—that mode consolidates errors too late to guide any next action, which is the one failure that the framework cannot forgive.

## What the 2026 Data Doesn't Tell You

According to the 2026 Stanford trial's subgroups, the one-attempt-delay rule is a clean result inside a narrow envelope. The same data contains edge cases where the effect weakens, reverses, or goes unmeasured—and those edge cases determine whether the rule survives contact with your curriculum.

The clearest reversal is first-time novices on high-intrinsic-load tasks. In a subset of learners with zero coding experience, one-attempt delay produced a higher early error rate—2.4 vs. 2.1 errors per problem—than immediate feedback. Withholding feedback forced absolute beginners to sit inside their confusion longer on the first pass. Time-to-skill still favored delay by 1.8 hours, so the rule was not inverted; it just carried a steeper error tax at the start. One-attempt delay is still the better endpoint for these learners, but expect a rougher opening stretch.

The domain ceiling is just as sharp. The headline gain was measured on procedural, code-tracing skills. On explanatory or conceptual knowledge—machine-learning theory was the test case—one-attempt delay produced only a non-significant improvement in a 2026 Stanford conceptual module (p = 0.23). Procedural errors have a discoverable next attempt; conceptual errors do not. When the learner has no obvious way to re-approach the problem, the delayed feedback simply funds a vague retry.

Temporally, all three studies were single-session training runs. There is no peer-reviewed evidence on multi-week spaced curricula, and after sleep consolidation the optimal error-to-feedback gap may need to grow beyond one attempt. A learner who returns to a problem three days later is a different cognitive state than one still in the session; the one-attempt rule is calibrated for the latter.

The trial also has a compliance gap. Some learners in the delayed group made no second attempt within roughly a minute and ended up slower overall. TraceBot's telemetry shows these stalls need a nudge, but the RCT did not include a scheduled-prompt condition. That omission is not minor: a nudge that lands inside that first minute might rescue most of the non-responders, while a nudge that fires immediately would collapse the delay back into the instant-feedback regime the data rejects.

The comparison table's winner assumes an AI-guided digital environment. In a low-tech paper tutorial, one-attempt delay cannot be implemented without an instructor standing by, and the research gives no guidance for non-digital settings. The rule is architectural, as the Decision Framework states—and paper has no architecture for event-stream timing.

Finally, demand characteristics. The immediate-feedback group knew they were in the "fast feedback" condition, which may have induced hurry-and-check behavior; a fully blinded replication is still pending. Until then, part of the headline gap could be perceived speed rather than actual feedback timing.

| Edge case | What the trial data shows | What it means for you |
| --- | --- | --- |
| Absolute novices (zero coding experience) | 2.4 vs. 2.1 errors/problem early; still 1.8h faster to skill with delay | Keep the one-attempt rule; expect a rougher opening stretch |
| Conceptual content (ML theory) | Non-significant gain (p = 0.23) | Rule validated for procedural skills only; do not oversell it for theory |
| Multi-week curricula | No peer-reviewed evidence after sleep consolidation | Pilot the gap; it may need to grow past one attempt |
| Non-responders | No second attempt within ~1 minute; slower overall | Add a scheduled-prompt nudge; the RCT tested none |
| Non-digital / paper tutorials | No instructor, no implementation path | Rule applies only to AI-guided systems like TraceBot |
| Unblinded conditions | Immediate-feedback group knew their label | Treat the headline as provisional until replication |

None of these edge cases rehabilitates instant feedback; they only mark where the one-attempt rule needs adjustment or further research. Across every AI-guided procedural condition, one-attempt delay still beats immediate feedback whenever the learner can actually make a second attempt. The decision rule stands—but its scope is narrower than the headline.

## Worked Case

The 2026 Stanford RCT's sub-study turned on a 3.7-second gap: the interval from the moment a learner began their next practice attempt to the moment the corrective message appeared. Forty technical-support employees learned a 14-step pandas data-cleaning workflow — specifically, "filter malformed rows with combined string and numeric conditions" — and the adaptive engine withheld its corrective message until exactly one practice attempt after each step's first error. A mean incorrect attempt ran 58 seconds; the message then landed 3.7 seconds into the next attempt. The message content was identical across groups; only its position in the attempt sequence changed.

That repositioning cut practice repetitions markedly. According to the sub-study, the immediate-feedback group required a mean of 4.9 practice attempts per step; the one-attempt group required 3.1 — a reduction, even though the one-attempt group eventually saw the same corrective messages. If feedback velocity were the causal ingredient, the zero-attempt group would have needed fewer attempts, not more. That is the cleanest refutation of the "faster feedback, faster learner" myth: instant feedback is not one-attempt feedback delivered faster; it is a different cognitive event.

The 72-hour transfer test shows the effect is durable, not a practice artifact. Applying the same filter logic to a new CSV, the one-attempt group finished in 18 minutes with 4 errors, versus 29 minutes with 11 errors for the immediate-feedback group. The delayed group did not merely complete practice sooner; they encoded the rule in a form that survived a three-day gap and generalized to unfamiliar data.

Error-type decomposition explains the mechanism. The one-attempt delay cut "repeated same-error" events (χ²(1) = 24.6, p < 0.001). When feedback arrives instantly, the hint is absorbed as part of the error event itself: the learner rereads it and re-attempts without ever activating their own representation of the rule. Forcing one attempt before the hint converts feedback into a confirmation or contradiction of the learner's own just-made prediction. That retrieval attempt, not the hint text, drives the reduction in repeated errors.

The cost was real and should be priced into any implementation. One-attempt participants spent 11 additional minutes during the 14-step practice waiting for feedback to appear — a tax that feels worse in the moment than in aggregate. It was offset by a 3.4-hour faster time-to-proficiency and a higher transfer score. The table below summarizes where each group won.

| Metric | Immediate-feedback group | One-attempt group | Winner and why |
| --- | --- | --- | --- |
| Practice attempts per step | 4.9 mean | 3.1 mean | One-attempt — fewer repetitions |
| Repeated same-error events | — | — | One-attempt — χ²(1)=24.6, p

Canonical: https://aitutorialmaker.com/blog/one-attempt-delay-rule-is-optimal-in-2026-stanford-rct.php
Markdown: https://aitutorialmaker.com/blog/one-attempt-delay-rule-is-optimal-in-2026-stanford-rct.php/index.md