AI Literacy: Ada, AI, and Verification

A self-study sequence about ordered algorithms, language-model generation, and why human verification matters. Work through the units in order; check yourself as you go.

Made with AI assistance and reviewed and verified by a human instructor before release. See Authorship and credits.
DEVELOPMENT REVIEW DEPLOYMENT - NOT READY FOR RELEASE

Before you start

The program often called the first ever written computed Bernoulli numbers — a description Unit 1 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. Ada wrote an exact, ordered procedure; a language model predicts plausible code. Ask the AI to reconstruct her 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 where they stop, not in what they teach. Pick one and the previous/next links on every page follow it; you can change it here at any time.

What each route covers, and where it stops

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 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.

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

1. What generative AI is for

28 min

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

26 min

Lovelace, the Analytical Engine, Note G, and what it takes to specify a computation exactly.

3. What a language model does differently

32 min

Next-token prediction set against deterministic execution, and why plausibility is not correctness.

4. Choosing the tool

29 min

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

28 min

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.

6. Meet the Bernoulli numbers

37 min

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

28 min

A deliberately underspecified prompt, and the plausible mistakes it produces.

8. Verification lab

52 min

Run generated code against an exact oracle, find the first divergence, and name the failure mode.

9. Grounding and citation checking

46 min

The module'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

40 min

Turning a vague request into testable requirements. Every clause is a bug that already happened.

11. Agents and automated actions

32 min

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.

12. High-stakes use and escalation

28 min

A second axis -- how much checking, from consequence, reversibility and your own uncertainty -- and the row where the answer is another person.

13. Privacy and data handling

25 min

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

23 min

Three obligations owed separately -- rights, attribution and disclosure -- and honesty about which of them has unsettled answers.

15. Bias, representation and accessibility

32 min

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

29 min

An error in a respected published table, the difference between an established fact and a repeated claim, and the module's own mistake with both.

17. Disclosure, defence, and responsible use

41 min

State what AI did, what you checked, and why your answer is right — three different statements.

18. Alles Lüge! First- and second-order reasoning

36 min

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