Self-check in your browser
Each unit carries its own checkpoints at the foot of its page, with diagnostic feedback. Your progress page collects all of them, and what you have recorded so far, in one place. Nothing to install, nothing uploaded.
Release candidate. The unit videos are added in the first release.
Before you start
The program often called the first ever written set out how to compute Bernoulli numbers — a description Unit 2 shows is contested, which is a good place to start. Let's use it to learn how to work with — and check — the newest kind of machine. Note G sets out an exact, ordered procedure; a language model predicts plausible code. Ask the AI to reconstruct Lovelace's computation, then do what her era couldn't do cheaply: verify it. The arc deterministic algorithm → statistical generation → human verification is the whole literacy story in one example.
Two things make this work rather than just read. First, every unit has a checkpoint you can pass or fail — a wrong answer tells you which misconception you have hit. Second, there is a verification lab that judges generated code against an exact reference.
Choose your route
Routes differ in which units they include; the routes page says what each covers and what it leaves out. Pick one and the previous/next links follow it on every page you open from here; turn on local progress to have the choice remembered next time. You can change it here at any time.
Your work stays with you
The optional progress tools save only in your current browser profile. Browser data can be lost, so keep important answers separately and download regular backups.
How to check your work
Self-check in a terminal
Clone the repository and run the verification lab and the same checkpoints locally, using the Python standard library. Nothing to install beyond Python 3.
The units
Nineteen units in six parts. The parts are the shape of the argument, not a schedule -- a route may take units from any of them, and the route you choose decides which ones you meet.
Before you begin
What the course asks of you, and what it does not. One unit, and the rest of the course rests on it.
0. Introduction and how to use this course
How to use the course, what AI systems produced, and the learning contract you are agreeing to.
What these systems are
What a generative system is for, where the ordered procedure at the heart of the course comes from, and how to work with a tool whose output you cannot take on trust.
1. What generative AI is for
Five classes of task sorted by where the reference lives, and why that -- not the topic -- decides what checking costs.
2. Ada's ordered procedure
Lovelace, the Analytical Engine, Note G, and what it takes to specify a computation exactly.
3. What a language model does differently
Next-token prediction set against deterministic execution, and why plausibility is not correctness.
4. Choosing the tool
Four kinds of system, what each one changes about the checking you owe, and what a query costs in money, time and energy.
5. Prompts, context and attachments
What actually reaches the system, why the window has an edge you cannot see, and why an attachment makes an answer checkable rather than true.
The worked case
The course's spine, worked end to end -- a result you can derive by hand, the same result generated, and the check that decides between them.
6. Meet the Bernoulli numbers
Enough mathematics to know what correct output looks like — including the two convention traps that make correct programs disagree.
7. Ask AI to generate the routine
A deliberately underspecified prompt, and the plausible mistakes it produces.
8. Verification lab
Run generated code against an exact oracle, find the first divergence, and name the failure mode.
Extending the method
The same method carried to work with no arithmetic in it -- sources, revision, and actions that reach outside the page.
9. Grounding and citation checking
The course's second worked case, run on a question with no oracle -- what a citation establishes, and six named ways one fails.
10. Re-prompting, specification, and overreliance
Turning a vague request into testable requirements. Most clauses are bugs that already happened.
11. Agents and automated actions
What changes when a system acts rather than answers -- an action can change the world before you have looked at it, so sort by what recovery costs and check the calls rather than the report.
Duties and consequences
What follows from using these systems on real work -- consequence, data, rights, the people described, and the faults printed in Note G.
12. High-stakes use and escalation
A second axis -- how much checking, from consequence, reversibility, your own uncertainty and whether it is yours to decide -- and the row where the answer is another person.
13. Privacy and data handling
What actually leaves your device, what is retained, and a classification by whose material it is rather than by how secret it feels.
14. Copyright and attribution
Three obligations owed separately -- rights, attribution and disclosure -- and honesty about which of them has unsettled answers.
15. Bias, representation and accessibility
The method run on its hardest object -- what one controlled comparison establishes, why absence escapes it, and the part with definite answers.
16. The historical bug and historical honesty
An error in a respected published table, the difference between an established fact and a repeated claim, and the course's own mistake with both.
Standing behind the work
What you attach to the work, and where the person checking it stands. The closing argument.
17. Defence, disclosure, and responsible use
Say why your answer is right, with evidence someone else can check; say how it was made; know which of the two carries the weight.
18. Alles Lüge! First- and second-order reasoning
The closing unit. Where the observer stands when it checks something, why that question is older than AI, and how to sort claims by the evidence actually behind them.
Reference material
- The course in brief (PDF) — the content of every unit in compact form, without the activities.
- The verification skill — instructions that tell an AI system to verify its work the way this course teaches and to hand you what you need to verify it; how to use it. For AI systems, the site also publishes llms.txt, which points them to the skill.
- PDF handbook — the complete course material in a single printable document, without the answers, so you can still attempt the work from it.
- PDF handbook, guidance edition — the same document with the marking guidance and the checkpoint answers. It is the guidance this site shows you after you answer; open it when you have attempted the work.
- Glossary — terms used across the course.
- References and source policy — what is cited, and the rules for citing it.
- Historical notes — the authoritative reference for every historical claim, with each marked established or contested.
- Evidence pack template — what you should have produced by the end.
- Second-order reasoning — the general argument the course is a worked instance of. Background for Unit 18.
- Misconceptions — expected errors across the course, and where each is addressed.
- Authorship and credits — who made what, including which parts were AI-generated.
- Accessibility, privacy, working offline, and the videos — what has been checked about this site and what has not, what is stored in your browser, what works without a network, and how the narrated videos are made.
Additional material
Two videos outside the units, for anyone deciding whether the course is for them or for their students. Neither is part of a route.
- An overview: what the course proposes, and why — video, about 25 min. A presentation of the course for viewers with a suitable background -- the problem, the method, the two worked cases, responsible use and how the course was made and checked -- without its activities. Published on YouTube with the first release. Version v0.1.0.
- Checking, not generating — video, under a minute. A YouTube Short that points viewers to the course -- generated code that looks right, checked against a reference and found wrong; the 1843 procedure it computes; and the three moves the course teaches. Published on YouTube with the first release. Version v0.1.0.