Unit 0: Introduction and how to use this course

Reading time: about 15 minutes. Activity: about 10 minutes.

1. What this course is

This is a self-study course about working with artificial intelligence. It is built around one example, and it stays with that example from the first unit to the last.

By artificial intelligence it means generative systems: ones that produce text, code, images or sound in answer to a request, such as a chat assistant. "Artificial intelligence" is the name of a field, not a measurement: intelligence has no agreed definition, and neither have understanding or consciousness, so this course uses none of them to say what a system is. It uses understanding in one sense only: your own grasp of the tools you use. Unit 17 looks at what the three words have been taken to mean, and why that matters when a claim uses them. Much of the AI around you is not generative. Systems that classify, rank, recommend or predict — a spam filter, a credit score, the order of a news feed, a tool that flags medical scans — fail differently: often silently and across many cases at once, so they are judged by measuring their errors over many cases rather than by checking one output. This course does not cover them, though its central question, what a claim is checked against, applies to them too. You will meet one kind in Units 9 and 17, the detectors sold to tell generated text or images from human-made, and Unit 15 returns to systems that classify or rank people.

In 1843 Ada Lovelace published a set of notes describing how a machine designed by Charles Babbage — the Analytical Engine, which he never completed — could be made to compute a sequence of numbers called the Bernoulli numbers (Lovelace 1843, Note G; on the engine, [S1], [S4] and [S12] in References and source policy). Her account is an ordered procedure: a fixed sequence of operations, with every quantity named and every step written down.

You are going to ask a modern AI system to reconstruct that computation. Then you are going to find out whether what it produced is correct, using a reference you built yourself.

The arc of the course is a loop of four steps:

1. An ordered procedure, which either follows its specification or does not.
2. A generated candidate, fluent whether or not it is correct.
3. An independent check against suitable evidence, which is how you establish which claims the output supports.
4. Revision, or a scoped claim: a candidate that fails goes back for revision; one that passes is a claim you can defend, as far as the check reached.

Most of the course is step three. That is deliberate. Generating output is now the easy part of most tasks; establishing that the output is right is the part that still needs you.

2. How this course was made, and what you can check

The videos are narrated by three synthetic voices designed for this course, each shown as a drawn robot. No person is speaking in them, and no real person's voice was copied to make them. The course was made by several AI systems working with a person, who reviews the work, gives advice, and releases and maintains it: the systems wrote almost everything you are about to read and built the code, the voices and the videos. AUTHORS.md names every system and the person. The course says so once, at course level, rather than on every file. Where a page reports what "one provider's documentation" says about a product's defaults, check your own tool's: providers document different defaults.

It says so because a reader is entitled to know how work was made, and because Unit 17 will ask you to write the same kind of statement about your own work. A course that asked you to declare your AI use, but did not declare its own, would be asking for trust it does not give.

Now notice what that statement is worth to you. You cannot confirm it from the text. Nothing in the text shows how it was made. If the statement were false, or incomplete, reading the material would not tell you. Records may back up parts of such a statement; they cannot show that the account is complete. Nor does it say the material is correct: "a person reviewed it" is a statement about process, and people miss things.

What you can check is whether the material is right, and the course is built so that you can:

• its whole source is published, so any claim can be traced to where it was made;
• the reference implementation that judges your work is itself tested against published tables of Bernoulli numbers, and you can run those tests;
• the historical claims cite sources you can look up, and Unit 16 shows you a facsimile of the page in question rather than a description of it; and
• the checkpoints and the verification lab let you check the central computation yourself.

That is the distinction the course rests on. A declaration asks to be trusted. A certificate, in the sense this course uses, is evidence that lets someone else repeat a check and get the same result, without having to trust whoever made it: a value they can recompute, a test they can rerun, a quotation with a page number they can look up. Checking a certificate is usually far quicker than producing the work in the first place, which is what makes it worth asking for. (The completion record the progress page can print is not one: it records what you said you did, and it says so.)

So: disclosure is the easy half, and using AI is not something to apologise for. The harder half is being able to stand behind the work: to understand it (in the sense the pause below spells out), and to hand over evidence that it is right that someone else could check. The course spends most of its effort there.

3. Not a new problem

None of this began with AI. Printed mathematical tables contained errors, and people who relied on them were misled. Textbooks repeat quotations their supposed authors never said. Programmers have always written bugs, and reviewers have always missed some. The Note G table, as printed in 1843, contains errors: one is legible in the facsimile [P2a], and a self-published reconstruction lists others [S7, sec. 5.2]. Unit 16, on the complete route, examines the one in operation 4. You could never be certain that work made by people was right, either; the habits this course teaches are the ones careful readers, editors, scientists and engineers already used.

What generative AI changes is mostly speed and volume. Fluent text, confident summaries and plausible code can now be produced in seconds, in quantities nobody can check by reading them closely, and they look finished whether or not they are. Checking slows you down. That is not a penalty for using AI; it is what responsible use of any source, tool or colleague's work has always cost, and the speed of generation only makes skipping it more tempting.

4. The learning contract

One sentence, and it does not have exceptions:

Using an AI system does not remove your responsibility for the output you put your name to.

Hand something on — submit it, publish it, send it, act on it — and if it is wrong you are answerable for having used it. Other people and organisations may also have responsibilities for design, deployment, policy, review, or harm. The learning contract does not settle those wider duties; it prevents you from treating the tool as a substitute for your own checking. Disclosure says where the work came from; it is not evidence that the work is right.

This is the course's whole subject, and it is worth seeing why it is put this way round. Whether a tool was used is often impossible to establish from the work — Unit 17 goes into that — so it makes a poor foundation for anything. Whether the work is right, and who is answerable for it, can both be established. So the question that runs through every unit is:

What would I have to check before I could stand behind this?

There is a separate question about permission: some material you may not send anywhere, and some tasks have rules about what help is allowed. Where such a rule exists you find out by asking, not by inspecting the finished work, and Units 13 and 17 deal with each in turn. It is a real constraint and a different one. It never answers the question above.

Pause rather than approve the result when you can no longer do any one of four things. Predict relevant behaviour. Explain the transformation from input to output, in as much detail as your claim needs. Name a suitable independent check. Interpret a failed check.

The words "in as much detail as your claim needs" matter. You do not have to explain the inside of a program, or of a statistical library, to use it — plenty of reliable tools are opaque inside and checkable outside. You need not explain the tool's inside, provided you can interpret its check; and you never claim more than that check supports. Confidence is not evidence and does not repair any of those gaps. Narrow the task, rebuild the missing foundation, or seek qualified review before relying on the result.

That question has different answers for different kinds of output. A calculation can be run against values you already know. A claim about the world has to be looked up. A low-risk first draft that you will rewrite may need less checking, but claims, personal data, confidential material, and consequential decisions still need appropriate handling. Unit 3 turns that into a working triage you can apply in seconds; the rest of the course makes you do it on a real example, where it is possible to be wrong.

Real-world and industry context

The same habit matters outside assessment. In software, data analysis, documentation, or workplace decision-making, the person who approves an AI-assisted result remains answerable for it. An unchecked generated snippet can introduce a security bug; an unchecked generated summary can misstate a policy; an unchecked calculation can be numerically wrong. Verification is not only an academic-integrity rule. It is a way to make work defensible.

5. How the course is organised

Nineteen short units. You do not take all of them -- the route you choose picks out a path through them, and the routes page says how long each one is. Most units take about 25 to 45 minutes in all, counting the video, the reading and the activity; Units 10 and 18 take about an hour, Units 8 and 9 a little more, and Unit 17 about 75 minutes. Spread it over as many sittings as you like.

Each unit gives you:

• a short video with slides (and a transcript, if you would rather read than watch);
• the reading. This page is one of them.
• the activity — the task. This is where the learning happens; skipping the activities leaves you with a story you have heard rather than a skill you have. Its marking guidance is shown to you once you have done the work, so you can assess yourself honestly.
• a checkpoint you can pass or fail, in the browser or a terminal.

The video and the reading cover the same content and follow the same path, so you can watch, read, or do both: you do not miss a core idea by choosing one.

You also accumulate an evidence pack as you go: your prompts, the outputs you got, what you checked, what you found, what you changed, and a short statement of why your final answer is correct. Unit 17, on a route that includes it, assembles it. It is yours: nobody collects it and nobody marks it. Start collecting from this unit.

6. What you need before you start

Stated plainly, because the course has assumed some of this without saying so.

What is assumed throughout. Exact fractions — adding, multiplying and comparing them, and being willing to keep -2/35 rather than turn it into -0.0571. Simple algebra: rearranging an equation to get one term on its own.

What is assumed in one place only. The Bernoulli unit asks you to work a value out by hand from a recurrence, which means reading a summation sign and a binomial coefficient. That is the only unit that does, and if it is unfamiliar, What you need before you start works both through on this course's own numbers before you get there.

What is not assumed anywhere. No calculus. No statistics. No prior programming — the table-based route runs the whole course without it. No prior use of an AI system, and no account with any particular provider.

What you need to have. A browser. Python 3 as well, only if you take the Python route, and nothing to install beyond it.

If the mathematics is the part you would rather avoid entirely, that is a supported choice rather than a lesser one: the route without the mathematics reaches the same method through a case that has no arithmetic in it. The routes page lists it.

7. Choose your learning route

No programming is required. "Route" means three things here: the routes page lists paths through the units; the two routes below are ways of doing the verification work in Units 6 to 8; and the self-check, further down, has a browser route and a terminal route. Choose one now, and switch later if useful.

Both routes teach the same core outcomes: specify what correct means, compare against evidence independent of the output being checked, diagnose disagreement, and state the limits of the check. They do not produce identical evidence, and in Unit 8 each has its own self-check question as well as two they share. The Python route establishes how the code behaves over the range the checking script tests. The table route establishes only what you compared by hand.

8. The self-check framework

Every unit has at least one checkpoint: a question you can pass or fail, tied to the unit's content. Checkpoints are formative — practice that gives feedback, not marks (see the glossary). Nothing here is marked and nothing is collected. They exist so that you find out you have misunderstood something in the unit where it is explained, rather than three units later.

The browser and terminal routes are of equal standing. For every browser-compatible checkpoint they ask the same question, accept the same answer, and give the same feedback because both are generated from one shared definition. The additional Unit 8 code checkpoint runs only in Python.

python3 selfcheck.py run <id>  # or in the browser

The terminal route lives in The verification lab and self-check and needs nothing beyond a Python 3 installation — no packages to install. The browser route needs nothing at all: each unit's page ends with that unit's checkpoints, and your progress page collects every checkpoint in the course together with what you have recorded so far. Neither sends your answers anywhere. The browser keeps them in this browser, once you switch recording on from the progress page; the terminal keeps them in a file on your own computer, course/lab/.selfcheck-progress.json. Use whichever you prefer, and switch whenever you like.

Three things worth knowing before you start:

• Feedback is diagnostic, not binary. A wrong answer that matches a well-known misunderstanding will say which one you have hit and point you at the unit that deals with it.
• Some checkpoints will not show you the answer, because deriving it is the point of the exercise. You get a hint aimed at your next step instead.
• The framework is explorable. python3 selfcheck.py explore lets you query the trusted reference implementation with your own inputs and compare two implementations against each other. Use it to poke at things, not only to be tested.

The answers to the checkpoints are, of course, sitting in a source file in this repository, and nobody is stopping you. Reading one before attempting it removes the diagnostic value of that checkpoint: the feedback is built to tell you which misunderstanding you have, and it cannot do that for an answer you did not form. Nothing is lost beyond that, and the guidance is there for afterwards.

9. If something does not work

This is a self-study course, so there is nobody watching for you to get stuck. Most difficulties have the same few causes:

• A checkpoint will not run in the browser. Some browsers block local storage on files opened directly from disk. Use the published course site rather than a downloaded copy, and take a portable backup either way.
• The Python route will not start. Nothing in the core course needs it. The browser route covers the same checkpoints except the Unit 8 code checkpoint, and the table-based work in Units 6, 8 and 16 needs no code at all.
• You have no access to an AI system. Every activity that asks you to generate something supplies a specimen instead. You will not be stuck, and the method is the same either way.
• Something looks wrong in the material. It may well be. The whole source is published — the link is at the foot of every page — so you can see how any claim was made, and the authors page carries an address for telling us. A course that asks you to check claims has to expect its own to be checked.

If you are taking this course as part of a programme, whoever is running it comes first: their rules on assessment and AI use are the ones that apply.

Before you go on

It takes about ten minutes and produces the first line of your evidence pack. Then answer cp00-contract and cp00-what-this-needs at the foot of this page, and go on to the next unit on your route.