Unit 0: Human introduction and how to use this module

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

What this module is

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

In 1843 Ada Lovelace published a set of notes describing how a machine designed by Charles Babbage — the Analytical Engine, which was never built — could be made to compute a sequence of numbers called the Bernoulli numbers. 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 module is three steps long:

1. An exact ordered procedure, which either follows its specification or does not.
2. Generated text, which is fluent whether or not it is correct.
3. Verification against suitable evidence, which is how you establish which claims the output supports.

Most of the module is stage 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.

The disclosure model

Almost everything you are about to read was drafted with AI assistance from a plan written by a human instructor, and reviewed by that instructor before release. The module says so once, at module level, rather than repeating it on every file.

There are two reasons for that, and neither is legal caution.

The first is that a reader of any piece of work is entitled to know how it was made. That is a low bar and this module clears it.

The second is that the module will ask you to write the same kind of disclosure about your own work in Unit 17. Material that demanded a disclosure it was unwilling to make itself would be asking for trust it does not extend.

Note what the disclosure does not say. It does not say the material is correct because a human reviewed it. It says a human reviewed it, which is a statement about process. Correctness is a separate claim, and it needs separate evidence, which is what the checkpoints, the reference implementation, and the verification lab are for.

One thing is worth saying plainly at the start. 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 say you understand it, and that you have evidence it is right.

Keeping "how this was made" apart from "why this is right" is a skill this module returns to repeatedly, and it spends most of its effort on the second one.

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 is a statement about provenance, not evidence of correctness.

This is the module'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 at the level your claim needs, identify a suitable independent check, or interpret a failed check.

That third qualification matters. You do not have to explain a compiler, or a statistical library, to use one — plenty of reliable tools are opaque inside and checkable outside. What you cannot do is claim more than your check supports while understanding neither. 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 module 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.

How the module 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. The middle units run about 25 to 45 minutes each; the opening units are shorter. 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);
• page.md — the reading. This page is one of them.

(Note: The video and the reading cover equivalent content and follow the same learning path. You can choose to watch the video, read the text, or both—you won't miss any core concepts by picking one format over the other.) - activity.md — 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.

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 assembles it. Start collecting from this unit.

What you need before you start

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

What is assumed throughout. Exact fractions — adding, multiplying and comparing them, and being willing to keep -1/30 rather than turn it into -0.0333. 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, course/prerequisites.md works both through on this module'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 module 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 code 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.

Choose your learning route

No programming is required. Choose a route now, and switch later if useful.

Both routes teach the same core outcomes: specify what correct means, compare against evidence independent of the candidate, diagnose disagreement, and state the limits of the check. They do not produce identical evidence. The Python route uses the code-only cp08-bernoulli checkpoint and the shared cp08-diagnose; the table route uses cp08-table-evidence and the same shared diagnostic. The first establishes executable behaviour over the checker's stated range. The second establishes only what was manually compared.

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; if you are taking the module inside a course that says otherwise, that course's rules are the ones that apply. 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 interfaces 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 Python route lives in course/lab/ 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 module together with what you have recorded so far. Both work from local files, make no network requests, and keep your answers in this browser. 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.

If something does not work

This is a self-study module, 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 module needs it. The browser route covers the same checkpoints, 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 module that asks you to check claims has to expect its own to be checked.

If you are taking this module inside a course, 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 the checkpoint at the foot of this page, and start Unit 2.