Unit 0: Human introduction and how to use this module

Reading time: about 10 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 8. Material that demanded a disclosure it was unwilling to make itself would not deserve to be believed.

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. And here is the part worth saying plainly at the start: disclosure is the easy half, and using AI is not something to apologise for; the important, harder half is being able to stand behind the work — to say you understand it and have evidence it is right. Keeping "how this was made" and "why this is right" apart 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 how you use and submit its output.

If something you submit is wrong, you remain answerable for using 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 has a practical consequence that runs through every unit. After checking whether the use is permitted, ask:

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

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, identify a suitable independent check, or interpret a failed check. 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 2 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

Ten short units: nine core, taken in order, plus one optional historical unit (Unit 7). The middle units run about 25 to 45 minutes each; the opening units are shorter. Set aside about four and three-quarter hours for the measured core route; a shorter route of about three hours ten minutes exists — see ../learning-paths.md. 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.
• 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 8 assembles it. Start collecting from this unit.

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 cp05-bernoulli checkpoint and the shared cp05-diagnose; the table route uses cp05-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) — unless your instructor says otherwise. 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 5 code checkpoint runs only in Python.

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

The Python route lives in course/lab/ and needs nothing beyond a Python 3 installation — no packages to install. The browser route is a single page that works from a local file, makes no network requests, and keeps your answers in the page; use the module website's self-check page if you were given a link, open dist/site/selfcheck.html from a downloaded release, or — if you are working from source — build/site/selfcheck.html, which exists only after make selfcheck has been run. 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. Nobody is stopping you. A learner who goes looking has spent their own time to avoid learning something, which is a poor trade in a module whose entire subject is the difference between having an answer and being able to defend one.

Where this sits in the wider course

This module is a case study inside a wider eight-item AI literacy course. It leads strongly on some items, touches others where the Ada and Bernoulli example genuinely supports them, and only signposts the rest.

See ../course-map.md for the item numbers, the item names, and this module's coverage level for each. That file is the single source of truth for those names, which is why they are not repeated here.

A learner who takes only this module should still finish with the story, the concept, the verification method, and the disclosure habit. A learner taking the full course should treat this as the practical half of the evaluation item.

Before you go on

Do the activity in activity.md. It takes about ten minutes and produces the first line of your evidence pack. Then take checkpoint cp00-contract, and start Unit 1.