Learning paths

This module is a fixed sequence of units, but you do not have to take all of it, and you do not have to take it the same way as everybody else. This page sets out the routes through it. For each one it says who it suits, which units you take and in what order, how long the material declares it will take, what you will be able to do at the end, and what you will not.

The last of those matters most. The useful question is not how many units you covered. It is what you can do afterwards that you could not do before, and where the edge of that is. Every route below is described in those terms.

All timings come from the duration_minutes block in each unit's metadata.yml, added up. Reading is measured at 180–220 words per minute with inspection allowances for code, tables, equations, and media; activities use a dry run of the required tasks. Your own pace will differ, so treat these as a planning range rather than a promise.

The units and what each costs

The core path is Units 0 to 6, then 8 and 9. Its declared central estimate is 286 minutes, about four hours and forty-six minutes; the measured reading range makes the route approximately 281–300 minutes. Unit 9 is not an appendix: it is the closing unit and it is required. Unit 7 is optional, sits outside that budget, and adds 29 minutes if you take it. Titles and course-item numbers come from course-map.md, which is canonical; the unit table with checkpoints and status is in index.md.

The 2.5–4 hour planning target is advisory. The measured route exceeds it because the required readings need more time than their early estimates allowed, Unit 6 includes transfer to claims with no automatic oracle, and Units 3 and 5 retain the derivation and verification practice that make the module more than a set of claims about AI. Optional extensions and Unit 7 remain outside this total.

The units have prerequisites, listed in each metadata.yml, and they are real rather than decorative. Unit 5 cannot check an artefact you did not generate in Unit 4. Unit 4 has nothing to compare against unless you derived the reference in Unit 3. Unit 3's traps only land if Unit 1 has shown you what an exactly specified procedure looks like. This is why the routes below differ in where they stop rather than in which units they skip out of the middle. Unit 7 is the one unit that lifts out cleanly: it depends on Units 3 and 5, and nothing depends on it, which is exactly what makes it safe to leave out.

Route 1 — The short route

Units 0, 1, 2, 3, 4, 5, in that order. 189 minutes, about three hours and nine minutes.

Who it suits. You want the module's actual skill and you cannot find three and five hours. You are willing to give up the parts about writing up and defending the work in order to keep the part where you check something.

This is the shortest route that still teaches something defensible, and it is worth saying plainly that it is not very short. The saving over the core route is about an hour and a half. There is no thirty-minute or ninety-minute version of this module, and offering one would be dishonest, because the module's point is not a fact you can be told. It is a thing you do: you ask an AI system for a computation, you build or obtain a reference independently, you compare them index by index, and you find where they part. That sequence needs a generated artefact, a trusted reference, and a comparison. Remove any of the three and there is nothing left to verify. Units 0 to 5 are the smallest set that gives you all three.

What you will be able to do afterwards.

• Say what changes when output is produced by next-token continuation rather than by an ordered procedure, and why that changes how you check it.
• Triage an AI output in seconds into what a test could settle and what only a source could settle.
• Derive B4 by hand from the recurrence and show your working, so that you hold a reference value you did not get from the thing you are checking.
• Explain why two correct-looking programs disagree about B1, and say which convention this module uses.
• Take a generated routine or a generated table of values, compare it against the reference index by index, find the first index where it diverges, and name the failure mode using the module's codes rather than saying "it is wrong".

What you will miss.

• Unit 6: turning a failure you observed into a specification clause that prevents it next time. You will be able to find bugs but not to systematically stop producing them.
• Unit 8: the disclosure and the defence. You will have checked your work and you will not have practised saying, in writing, how it was made and why it is right. Whether any course asks you for it is up to your own institution — this module sets no assessment rules — but it is the part most worth being able to produce.
• Unit 9: the closing unit, which offers one published way of reading everything you did — an interpretive lens, not the reason the verification works, which the oracle and the independent references already supply — and asks you to sort three of its own claims by what actually supports them. Without it you have the technique and not the reason it works, and the reason is the part that travels to problems that have nothing to do with Bernoulli numbers.

Unit 7 is absent from that list, but it is not something this route gives up: it is optional for everybody, and the core route does not include it either. See "Optional material" below.

Route 2 — The core route

Units 0 to 6, then 8 and 9, in that order. 286 minutes, about four hours and forty-six minutes. This is the default.

Who it suits. Everybody, unless you have a specific reason to be on another route. It assumes no computer-science background and no programming. It is the route the module is designed around and the one the time budget is set for.

Spread it over as many sittings as you like. Natural breaks fall after Unit 3 (you now hold the reference), after Unit 5 (you have found the divergence), and after Unit 6. Units 8 and 9 come to 62 minutes together and make a good final sitting: one writes the work up, the other says why the whole procedure was sound.

Unit 7 is not in this list, and its absence is a decision rather than an oversight. The module ran long, and the lesson Unit 7 works through at length — that published does not mean true — is also recorded as expected error 12 in misconceptions.md, so the core path carries it either way. Skipping Unit 7 leaves no hole. Taking it is a good use of 29 minutes once you have the core.

What you will be able to do afterwards. Everything in the short route, and:

• Take a failure you have actually observed and write it as a specification clause, which makes the same failure easier to catch or rule out next time — though a generative system offers no guarantee it will never recur.
• Say why asking the same system to check its own answer is not independent verification.
• Write two different things that are commonly confused: a disclosure, which reports how the work was made, and a defence, which says why it is right. A defence that cites the tool rather than the check is not a defence, and you will be able to see that in your own writing.
• Hold a complete evidence pack: prompt, output, what you checked it against, by what method, what diverged, what you changed, and why the final answer stands.
• State the general argument behind the whole module in one sentence, and point at three things you actually did that are instances of it.
• Tell a first-order treatment of a problem from a second-order one, and say which indices a claim is carrying — who observed it, in what context, with what record.
• Distinguish a proved theorem from an established research programme that nobody proved, and both from an overclaim, when all three appear on the same well-written page. That is the reading skill that makes the rest of it usable outside this module, and Unit 9 asks you to apply it to Unit 9.

What you will miss. The optional Unit 7, the optional CS extensions, and the per-unit optional extensions at the end of the Unit 1, 2 and 4 activities. None of it gates anything. A learner who finishes Unit 9 has completed the module, and the module says so in its own canonical map.

Route 3 — The core route plus CS extensions

Units 0 to 6, 8 and 9, plus the optional Python work. 286 minutes of declared core time, plus about 30 minutes of extensions that carry an estimate and three that do not.

Who it suits. You write code, or you are on a computing programme and want the version of this that engages with testing rather than only with judgement. The module's focus is computer science, and this is the route that shows it. It is recommended if you program, and it is not required of anybody.

Take the core route as written, and add the extensions at the points they appear:

The extensions sit outside the core time budget by design. Three of the six now carry a declared estimate, about 30 minutes between them; the other three do not, so no honest total is available for this route. The declared figure is 286 minutes for the core; plan a further sitting for the extensions rather than trying to fit them into the same one.

What you will be able to do afterwards. Everything in the core route, and:

• Write a test rather than run one. You will find out, concretely, that a test checking B4 == -1/30 lets two of the four faulty implementations straight through, and you will have to do better than that.
• Distinguish an inexact representation from an incorrect method when reading someone else's numerical code, because those fail differently and are fixed differently.
• Convert between two indexing schemes correctly, including rejecting the indices that have no counterpart at all — which is where off-by-one errors actually live.
• Say what your existing test suite covers, run it against AI-assisted changes, and produce evidence for where the assistance helped and where it did not. Changes that altered behaviour your tests did not cover are the most informative category, because they tell you where your suite is thin.

What you will miss. Only the optional Unit 7, and the optional extensions in Units 1, 2 and 4 that are not about code. Note also what the extensions do not add: they do not teach a different verification idea from the core route. They give you a second way to practise the same one, with the machine doing the comparison.

Route 4 — The complete route

Units 0 to 9, including the optional Unit 7, plus the CS extensions if you want them. 315 minutes of declared time, about five hours and fifteen minutes.

Who it suits. You have the time, and you want the historical case worked through properly rather than summarised.

The one thing this route adds to the core is Unit 7, and it is worth being precise about why Unit 7 sits outside the core, because "optional" is easy to misread as "filler". Unit 7 is not lighter than the rest and it is not remedial. It is the unit that works hardest on sources: it cites a primary text, it states plainly which part of the standard account is established and which is contested, and it refuses to settle in passing something the record does not settle. That refusal is the module practising in front of you what it asks of you everywhere else. It was made optional because the first full assembly ran well over the target and the module needed to be shorter, and because its transferable lesson is recorded in misconceptions.md entry 12 so the core path does not lose it. Length was the reason. Quality was not.

What you will be able to do afterwards. Everything in the core route, and:

• Establish a value independently first and only then compare it against a famous printed table, so that a primary source becomes something you can check rather than something you defer to.
• Sort a claim into established, contested, or unsourced, and say what specific evidence would move it between those buckets. For the Note G error those movers are concrete: a facsimile or physical copy of the 1843 printing, a comparison across print runs, surviving manuscript material.
• Spot the misfiling that most bad claims start with — something contested or unsourced quietly recorded as established, and thereafter repeated with the confidence that only the first bucket earns. Repetition is not corroboration: ten sources that all trace back to one unchecked account are one source.
• Write at three different strengths, so that the confidence of your sentence matches the state of the record rather than the state of your memory.

What you will miss. Nothing this module offers. Note the boundary anyway: this module does not cover fairness, representation, privacy, sustainability, or industry practice properly. It signposts them. The wider course covers them, and course-map.md records which items this module leads on and which it only touches.

Route 5 — The no-code route

Units 0 to 6, 8 and 9, in order, using table-based verification throughout. 286 minutes, the same as the core route.

Who it suits. You do not run Python and do not intend to. This is a complete route to the full set of the module's core outcomes. It is equal in standing to the route that runs code and produces a complete evidence pack. It is not a reduced version of anything.

What changes is the method of comparison, not the presence of it.

• Unit 5 provides two full routes through the verification lab, Route A and Route B. Route B is the table one. You ask the AI system for the values rather than the program, write the two columns side by side in index order, go down the rows, and stop at the first row that differs. That is the first divergence, found by hand, by the same method the checker uses.
• Checkpoints use the same browser self-check. Twelve core checkpoints are shared; Unit 5 substitutes cp05-table-evidence for the Python-only cp05-bernoulli so that each route is assessed against evidence it can actually produce.
• The evidence pack has a table-based version worked through in full in learner-evidence-template.md.

What you will be able to do afterwards. Everything listed under the core route. The capabilities are the same list, reached by a different comparison method.

What you will miss, stated exactly. The table route and the automated route each miss things, and the module is explicit about both. The table comparison will not tell you whether a program actually produces the table it printed — a table in a chat window may be generated text rather than program output, and those are two different claims. It says nothing about indices you did not compare. It does not re-run itself when something changes. Against that, the automated checker cannot tell you whether the convention it enforces is the one your task requires, says nothing about comments, historical claims, licensing, or readability, and cannot tell you whether you understand the code. Neither route is complete. Both are real verification. If Python is available to you and you are not on this route by preference, doing the table comparison for B0 to B12 and running the checker takes about five minutes together and covers more than either alone.

Optional material, and what optional means here

Optional in this module means: work that nothing else depends on, that no checkpoint requires, and that is worth doing once the core argument has landed. It does not mean easier, lesser, or intended for anybody in particular. The core path is the same for everybody, and the optional material is where the module put what would not fit in it.

There are three kinds, and they are different in scale.

Unit 7 — a whole optional unit, 29 minutes. Described under Route 4 above. Its checkpoint cp07-note-g is an optional checkpoint, and it carries an optional extension of its own that runs the same three-bucket test on generated text. It requires Units 3 and 5, and nothing requires it.

Per-unit optional extensions — Units 1, 2 and 4. At the end of each of those activities there is a section headed "Optional extensions", each task carrying its own estimate. These are not new busywork: they are the tasks that used to be part of the required activity and were moved out when the module was shortened. Nothing was deleted. If an activity felt like it stopped early, this is where the rest of it went.

• Unit 1 — about 25 minutes across three: repair the remaining gaps in your procedure, run the literal-reader pass on somebody else's, and (for programmers) rewrite the procedure as a Note G-style variable table.
• Unit 2 — about 12 minutes across three: name the de-risking condition for every item you marked L, build the full list of things that feel like independent verification and are not, and rewrite your three weakest checks as checks somebody else could run.
• Unit 4 — about 24 minutes across four: extend the triage table, make the mirror-image prediction, triage a second specimen from lab/examples/, and (for programmers) read a specimen without running it.

CS extensions. Route 3, and the table there.

One piece of ordering advice, since all of this competes for the same evening. Take the core first. Optional work is what you reach for once the core argument has landed; reached for before that, it costs you the end of the module and gives you no way to tell what you have gained.

If you only have 45 minutes

Then you cannot do this module, and it is better to say so than to sell you a route that ends before the point.

What 45 minutes genuinely buys is orientation. Complete Unit 0 (23 minutes), then use the remaining time to begin Unit 1 and keep your answers separately so you can resume. You will finish the learning contract: using an AI system does not remove your responsibility for how you use and submit its output.

You will not have checked anything. You will not have derived a reference, seen a plausible output be wrong, or found a first divergence. Unit 2 is also written to follow Unit 1, so you will meet references to a contrast you have not been shown.

Do not skip directly to Unit 2 to manufacture a 45-minute mini-route: Unit 2 assumes the ordered-procedure contrast from Unit 1. Starting the short route and resuming later is more coherent than claiming completion before any verification has happened.

Where you can stop, and where you should not

Some stopping points leave you with something coherent. Others leave you holding the setup without the payoff, which is the worst of both — you spent the time and you did not get the skill.

Good places to stop.

• After Unit 0. Honest but thin. You have the contract and know how the module works. Nothing has been verified.
• After Unit 3. A defensible small win: you can derive B4 by hand, you know the two conventions exist and which one is in use, and you can translate between Lovelace's Note G labels and modern indices. You have a reference. You have not used it on anything.
• After Unit 5. The best early stopping point in the module, and the end of the short route. You have generated something, checked it against an independent reference, found the first divergence, and named the failure mode. That is the skill the module exists to teach.
• After Unit 8. A real stopping point, and the end of the practical arc: you have verified something, specified against the failure, and written both the disclosure and the defence. It is not the end of the module. Unit 9 is 30 minutes and it is where the thing you did gains a general reading you can carry elsewhere — offered as one published position, not a proof.
• After Unit 9. You have finished the module.

Bad places to stop.

• After Unit 4. The single worst place. You have a generated artefact, a triage of it, and no verification. You have done the part that was already easy and stopped before the part that is the module. Twenty-two more minutes of video and reading gets you into Unit 5.
• Part-way through Unit 5. If you have set up the lab, or written out the two columns, and stopped before comparing them, you have paid the setup cost and taken none of the return. Finish the comparison.
• After Unit 6, without Unit 8. You can verify and you can specify, and you have not written the disclosure or the defence. Unit 8 is 32 minutes and it is the unit that turns everything before it into something you can hand to somebody else and stand behind.
• After Unit 7, having taken it in place of Units 8 and 9. Unit 7 is good, and it is not a substitute for the end of the module. If it is a choice, finish the core and come back to Unit 7 afterwards; nothing in it expires.

Checkpoints, on every route

Every unit has at least one self-check checkpoint. Twelve core checkpoints and the optional Unit 7 checkpoint are available in both the browser and terminal interfaces. Unit 5 additionally has one Python-only executable checkpoint and one browser-compatible table-evidence checkpoint; a learner completes the one for their route. All definitions still come from one shared source.

python3 selfcheck.py run <id>          # or use the browser self-check

Whichever route through the module you take, the checkpoints are how you know it worked. They are not decoration at the end of a unit and they are not a quiz. A wrong answer that matches a known misunderstanding tells you which one you have hit and points you at the unit that deals with it, which is why taking them in the unit is worth more than taking them at the end. Some will not show you the answer, because deriving it is the exercise; you get a hint aimed at your next step.

The checkpoint ids for each unit are listed in index.md and in course-map.md. The terminal route and the lab live in lab/README.md.

Your evidence pack

You accumulate an evidence pack as you go, and Unit 8 assembles it. It is a private formative self-check. It is yours, it is not submitted, and it is not marked. Its only purpose is to let you see, in one place, the distance between "I generated this" and "I understand and can defend this" — and to let you notice when that distance is larger than you assumed.

Because it is not submitted, the incentive to tidy it up runs the wrong way. Paste the prompt as you sent it, including the part you got wrong or left out. The gaps in that prompt are the evidence. The template, with a worked example for each route, is in learner-evidence-template.md.