120 hours to overqualified

Ten days. One topic per day, fully immersed — then that topic comes back, smaller and harder, until you can produce it cold. Built against the StudyFix codebase and against the learning science in your own strategy folder.

How this course is built — and what the evidence actually says

Every structural decision below comes from the research in business/strategy/ and business/engineering-plans/research/. Tiers are quoted as your own corpus tiers them. Inflating a tier is the one thing Howard is instructed to treat as a firing offence, so nothing is inflated here.

The two that carry the weight — HIGH utility, meta-analytic

Immersion is correct — and so is the return

The one-line system

The five jobs — each return does a different one

Your 5-pass engine (§3.5, LOCKED) says: "Each pass does a different cognitive job. That is the entire point. A pass that repeats the previous pass's job is a wasted pass." Mapped to code:

The five jobs in this order are Tier 3 — coherent design inside a supported principle, not a tested protocol. The retrieval and spacing underneath them are Tier 1.

Run warm. This is the rule most self-taught plans break.

The cue ladder — pre-committed, because you can't judge your own level

LAW 7 (expertise reversal, Sweller): "The fade is automatic because the student cannot judge their own expertise level — that judgement is exactly what the fluency illusion corrupts." So the rungs are set in advance, on the calendar, not by how you feel on the day:

RUNG 4  full worked example open beside you, type it       ← immersion block, hour 1
RUNG 3  file skeleton + comments, you fill the bodies      ← immersion block, later hours
RUNG 2  function signatures only, no bodies                ← first return (+2 days)
RUNG 1  one-line description of what it should do          ← second return (+4 days)
RUNG 0  the name of the feature. Blank file.               ← final return (+7 days)

If you get less than half at any rung, step DOWN one rung. Do not grind.

Generation without correction is theatre

Close the reference before you explain

Koh, Lee & Lim 2018 (Appl Cogn Psychol 32:401–410): teaching without notes ≈ retrieval practice; teaching with notes ≈ control, at one week. Your own ELI5 doc puts it as "a ward round with the notes in your hand" versus one where "someone took the notes away." Same four minutes, all of the benefit in one of them.

So: when you explain what a piece of code does, the file is closed and the AI chat is closed. Out loud, not typed — oral explanation shows the benefit, written repeatedly doesn't. Hoogerheide et al. 2016; Lachner et al. 2020 — the latter is flagged in your own corpus as "could not verify", so treat the oral-vs-written margin as directional.

The five prompts — and the two that are banned

Bisra et al. 2018 (Educ Psychol Rev 30:703–725, g=.55 overall) ranks prompt types: conceptualize g=.87 · explain g=.68 · justify g=.42 · metacognitive g=.19 (n.s.). Use the top of that list. Ask yourself these five, out loud, after every feature:

1. What does this do, to someone who has never seen a browser?
2. What breaks if I delete it — and what breaks because of that?
3. Why does it work that way rather than the obvious other way?
4. How is this different from [the sibling API], in one sentence?
5. Say it again in plain English. (Re-probe yourself on any vague sentence — that's the Chi 1994 mechanism: keep talking, don't let vagueness pass.)

Banned: "How confident am I?" — metacognitive prompts are the one category with no detectable effect, and LAW 10 says the answer is worthless anyway. Multiple-choice self-quizzing — g=.24, not different from zero. Never pick from a menu. Always produce.

Nail the rule, then immediately hunt the exception

Explain correct code, not your own untested reasoning

Constraint #2 of the same paper: explaining your own reasoning is weaker than explaining known-correct information, and can be neutral-to-negative when your reasoning is often wrong. So: self-explain working, tested code and real docs. Do not spend an hour explaining your own untested architecture decision to yourself — you'll cement whatever's wrong in it.

The objective signal overrides the self-mark

LAW 10: "Fluent material feels learned; ease of processing is mistaken for strength of memory." And it's worse for beginners — poor performers are more overconfident (PMC6775028). So every day below ends with an objective check: a thing that runs or doesn't, on a live URL. "I feel like I got it" is not admissible evidence and does not close a day.

The honest problem with a 120-hour fortnight

The shape — one topic per day, four returns each

Read down a column to see a day. Read across a row to see a topic's life. Colours are cue rungs: encode (reference open) · derive (reference closed) · blank file.

Every day has the same two-part shape:

• Return block — 60–90 min, first thing. Yesterday-and-before, at a harder rung, reference closed. It's first because retrieval before new material also acts as pretesting, and because it's the block you'll skip if you leave it till you're tired.
• Immersion block — 10–11 hours. One topic, uninterrupted. Reference open, worked examples open, AI on. This is where you learn.

Breaks: 15–20 min every ~90 min. Your own research calls incubation productive — "stepping away lets stuck problems resolve" — and says to build breaks in rather than grinding to exhaustion. The 12 hours below are work hours; breaks sit on top.

Five rules that keep this from collapsing

The architecture call

The ten days

The security six — read now, and again on day 9

Almost every breach of a small app is one of six mistakes, none of them exotic. An AI will happily write code containing all six, because the code works — insecure code is not broken code, which is exactly why testing won't catch it.

The security prompt — run before every commit

Review this code as a security auditor. For each issue give the
severity and the exact fix. Check specifically:
1. Any secret reachable from the browser
2. Any database access not protected by RLS
3. Any endpoint that doesn't re-verify the session server-side
4. Any user input used without schema validation
5. Any user identity taken from the request instead of the session
6. Any model output that gets executed, rendered as HTML,
   or used to build a query
7. Any AI endpoint without a rate limit or input size cap

Do not tell me it looks fine. Assume there is at least one issue
and find the most serious one.

When you're stuck

Read the stack trace bottom-up: the last line is the error, the lines above are the path that got there. Ask by pasting the entire trace, not your summary of it — say what you expected, what happened, and what you already tried. Never "it doesn't work"; that sentence contains no information.

What you are deliberately not learning

All real, all useful, none load-bearing for shipping this. LAW 9 is the justification: far transfer is mostly a myth, so there is no general-thinking module to take — judgment falls out of a large store of concrete, stack-specific patterns plus reps at telling them apart.

• Linear algebra, calculus, statistics for ML
• PyTorch, TensorFlow, training or fine-tuning models
• Transformer internals, attention, backpropagation
• Data structures & algorithms interview prep
• CSS from scratch — Tailwind plus AI covers it, and your structure is already approved
• Docker, Kubernetes, AWS, CI/CD pipelines
• TypeScript generics, design patterns, testing frameworks as a subject

And three study techniques your own research rules out: highlighting, rereading and summarisation are LOW utility (Dunlosky). Mnemonics are a last resort for genuinely underivable facts, then tested — never the default. Multiple-choice self-quizzing is g=.24, statistically indistinguishable from zero. Produce; never pick.

After day 10 — the re-entry schedule

Honest evidence status — what I am and am not claiming

• Tier 1, safe to lean on: retrieval practice (g≈0.50) and spacing (d≈0.54). The whole return-block structure rests on these two and nothing else needs to hold for it to be worth doing.
• Tier 2, strong: transfer-appropriate processing, cognitive load theory and faded scaffolding, expertise reversal, hypercorrection, the closed-book explanation finding.
• Moderate — real but not proven: self-explanation (g≈.55 vs passive, but only g≈.30 against another active strategy, which is the number that applies here since you're already building), elaborative interrogation (d=0.46 immediate, 0.28 delayed — it fades), interleaving ("ultimate effectiveness currently unknown" — Dunlosky).
• Design, not evidence: the specific five passes in that order at those intervals are Tier 3 in your own corpus — "coherent design inside a supported principle". The "smaller and harder" slogan is a design rule.
• Withdrawn, do not repeat: the "five passes because the forgetting curve reaches its asymptote" justification was retracted on 2026-08-01 as folklore. Five is arithmetic — horizon ÷ gap. For a 10-day horizon that arithmetic gives 5–7 touches, which is what the matrix above uses.
• Banned figures: the dual-coding "~65%" number (traced to a weak source, cut by your own 2026-07-13 audit) and the "Daley et al. 2014, d≈0.7–0.9" citation (Howard could not locate a matching paper, flagged three times). Neither appears here.
• Not in your corpus: "learning styles" is neither endorsed nor rejected anywhere in these files — it isn't mentioned. Worked examples exist only as Berthold's "faded, partially-completed prompts". Analogy and concreteness are demonstrated in Howard's prose but never stated as rules. I haven't attributed any of these to your research.
• LAW 13 (compression) is unbuilt and uncited — the manifesto itself calls it a representation argument, not a memory finding, and names its own falsifier. The drop-what-you-own rule in the return blocks uses it lightly; nothing here depends on it.