Unit 17: Defence, disclosure, and responsible use

Reading time: about 35 minutes. Activity: about 14 minutes. Checkpoints: cp17-disclosure and cp17-scope-the-claim. Before this unit: Unit 10 (re-prompting and specification), or on the responsible-use route Unit 9, as the verification grounding. Unit 16 (historical honesty) is on the complete route only and is not assumed here.

This is the last unit of practical work. It gives you the two written statements that turn everything you have done into something another person can read and rely on. On the complete route, Unit 18 then closes the course by naming the general question all of this has been circling; on every other route that includes this unit, this is where your route ends.

1. Two sentences that are not the same sentence

"Parts of this were drafted with AI assistance."

"This is correct because I checked it against values I derived myself, and here is what the check showed."

The first is a disclosure. It answers how was this made.

The second is a defence. It answers why is this right.

Both are statements about the same piece of work. They are separate statements, they answer different questions, and neither one substitutes for the other.

The second can be checked, but only if its check can be repeated. "I checked it" is still your word until someone else can rerun the check and get the same result; section 2 calls what makes that possible a certificate.

Why the substitution is tempting

Disclosure feels like it should be enough. You have been honest. You have hidden nothing. Surely the responsible thing is done.

It is half done. A reader who knows exactly how your work was produced still knows nothing about whether it is correct. Provenance is not evidence. An honest disclosure attached to a wrong answer produces an honest wrong answer, and the honesty does not repair the wrongness.

The two do not fail alike. Where a rule requires a declaration, leaving it out breaks the rule however good the work is, and you owe a reader an honest account in any case. But a reader who holds your evidence does not need your provenance to check your result: they can check it whoever, or whatever, produced it. That is what makes the evidence worth more than the declaration.

Two statements, two questions, and they do not carry equal weight. Only the defence can be repeated by a reader; a disclosure can at best be corroborated in part.

Which one carries the work

Both belong in honest work, and disclosing AI assistance is the easy, blameless part: using AI is not a problem, and you should say plainly where you used it. But a disclosure never makes anything correct. The claim that carries the work is the other one — being able to say, on your own authority, "I understand this well enough to defend it, I have evidence that it is right, and I can show you both."

That is a claim of ownership, and it has two separable parts.

Understanding is being able to predict what the thing does. You test it by predicting what your checks will show, then running them to see whether your model matches the thing's behaviour. (This is the course's working account; see the glossary.) A pass you did not predict tells you about the thing, not about your understanding of it.

Correctness is the further claim that the thing you understand is also right: that the specification it meets is the one you wanted. The two come apart. You can understand something perfectly and have it be wrong.

This course's own history shows a neighbouring gap, between a result and the object it describes. Its makers ran a faulty reading of Note G's table (Lovelace's 1843 table of operations, which has more than one printed fault: historical-notes.md, and Unit 16 on the complete route). They got 139/630 and reported that number as what "the table as printed" produces. It is not: that run had silently repaired a second printed fault (Historical Notes §4). It was a correct computation, of an object nobody had said was being run.

Understanding without a correctness check is not yet a defence. A defence that does not say what it is a claim about is not one either. And disclosure without either is not a defence at all.

So give the defence first, with something behind it that another person can check, and disclose plainly where a rule requires it or it helps the reader. The defence is the part that decides whether the work is any good.

Ownership also gives you a stopping boundary. Pause rather than approve work when you can no longer predict relevant behaviour, explain the transformation that produced the result at the level your claim needs, name a suitable independent check, or interpret a failed check. A confident feeling and a polished output are not evidence. Narrow the claim, rebuild the missing understanding, or ask a qualified reviewer before putting your name to it.

2. The defence, and the certificate behind it

A defence is about evidence. It carries three things:

1. What you checked.
2. What the check showed.
3. Which specification or assumption the check was against.

That third item is the one people leave out, and leaving it out hollows out the other two. "All tests passed" is worth very little if a reader cannot tell what the tests were testing for. Passing tests against the wrong convention is exactly the failure this course has been circling since Unit 6.

Unit 10 gave the difference two names. Verification asks whether the work meets its specification: the checker verifies a routine against the interface contract. Validation asks whether the specification is the right one: whether that contract, with its convention, is what the task needed. A passing check establishes the first; the third item of your defence is where you answer for the second.

What a defence never cites

• That the system stated the answer was correct.
• That the output sounded confident, or was long, detailed, or well formatted.
• The name or version of the tool. That is provenance; it belongs in the disclosure.

This is not a point of etiquette. Ordinary confident wording can accompany correct or incorrect generated text, so wording alone does not establish correctness. Research has found that specially elicited or trained confidence measures can discriminate answers on some evaluated tasks, but calibration (how well a stated confidence matches how often the answers turn out right) varies by model, task, prompting method, and distribution [L4, sec. 1.1]. This course gives you no validated confidence measure for the Bernoulli task, so a confident phrase or self-rating is not part of the defence.

A defence can rest on test results, checked reasoning, primary sources, independent measurements, or qualified review, chosen to match the claim. The source must provide relevant evidence rather than repeat the assertion being checked.

Independent-check principle: the evidential basis must not be controlled only by the system whose output is under review. Put simply, your evidence must not come only from the system you are checking. Asking the same model to endorse its first answer, or trusting a routine's own claim that it passed, produces another assertion rather than independent support. Use a separately established reference, direct observation, a different method whose dependence you understand, or a qualified reviewer as appropriate to the claim.

The certificate behind the defence

A defence is two sentences, and two sentences are still only a claim. What makes them worth something is what they point at: a certificate, meaning evidence packaged so that someone else can check your claim without having to trust you, the tool, or this course.

A check counts as a certificate only if someone else can repeat it and get the same result: its steps, its inputs and its reference are recorded. A check only you can vouch for still supports your defence, but it is not yet a certificate.

• On the checker route, the certificate is the command, the range it covered and its output. Anyone can rerun it in seconds.
• On the table route, it is the comparison table with the source of every reference value. Anyone can recheck any row against the published table.
• For a claim about a source, it is the quotation with its locator: the page, section or clause. Anyone can open it and look.
• For a historical claim, it is the facsimile, not a description of it.

Checking a certificate is usually far quicker than producing the work. Getting a correct Bernoulli routine takes the course from Unit 7 to Unit 10; checking that B8 = -1/30 against a published table takes a few seconds, and so does substituting claimed values into the recurrence and seeing whether the sum is exactly zero. Outside this course the asymmetry is often larger still: a factorisation of a large number is hard to find and is checked by multiplying it out; a long proof is hard to write and, written for a proof checker, is checked mechanically. That asymmetry is why a certificate is worth asking for, from yourself and from an AI system. "Give me the answer" invites a claim; "give me the tests and the command", "give me the passage and its page", or "show the intermediate values" invites something you can check. What the system hands you is still only a candidate certificate until you check it against something it did not produce: a test generated alongside the code can encode the same wrong interpretation of the task, and a locator it supplies may not exist.

What a proof checker certifies. A proof written for a proof checker is checked mechanically, step by step, and it still certifies less than it can seem to. The checker establishes that the proof derives the formal statement from its hypotheses and definitions. It does not establish that the statement, the hypotheses and the definitions say what was meant: that is validation, and it stays with a person. One 2026 preprint, on a security proof developed by researchers working with AI agents and checked by the Lean proof assistant, describes exactly this split: because the checker covered every proof, the authors could focus their review on whether the statements and definitions expressed the intended claim, and that review caught an AI-generated protocol that computed the key from both parties' strings combined, which neither party held on its own [L18, sec. II]. Two cautions follow, one the paper states and one this course draws. A definition can be met trivially: the paper notes that under its security definition alone a protocol that always aborts (stops before it produces a key) would count as secure, which is why that definition is paired, following earlier work, with a bound on how often an honest run aborts [L18, secs. III.B, IV.C]. And modelling assumptions can be built into definitions or stated as hypotheses; a list of the foundational axioms a proof uses, which a proof assistant can print, does not list them all. The paper states openly that its protocol assumes an authenticated channel, one on which an attacker cannot pose as either party [L18, sec. IV.A], and a whole result can rest on an assumption of that kind. Before you rely on "proved", read what was proved and under which assumptions, ask whether each assumption holds where you will use the result, and ask what the laziest thing is that would also pass.

A system's own account of what it did is not a certificate either. "I ran the tests and they pass" is generated text; the certificate is the test output you can see or rerun. Displayed "reasoning" is generated text too, and is not guaranteed to be the computation that produced the answer.

Two-sentence defence template

Correctness defence
-------------------
<Final result> is correct under <the stated specification or convention>,
verified by <the specific check> which showed <the specific outcome>.

The <discrepancy / assumption / convention> I found was <what it was>, which I
resolved by <what you did>.

All three ways of verifying produce a real defence

These routes have equal standing in this course, but they do not produce identical evidence. Each defence must state its actual coverage and limitations.

Table-based verification:

The values I checked from B0 to B8 agree under the first Bernoulli
convention (B1 = -1/2): I derived B4 from the recurrence by hand, took
the remaining values from the course's published table, and compared
the generated table against them term by term.

The discrepancy I found was at B1, where the generated version gave +1/2; I
traced this to the second convention and corrected the specification.

Automated verification:

The routine agreed with the oracle under the interface contract in
Unit 10 for every n from 0 to 30, returned exact Fraction values on those
inputs and satisfied the odd-term property over that range, which is not
a claim about n > 30.

The discrepancy I found was float output from B0 on, reported as
`not-fraction`, which I resolved by requiring exact Fraction returns.

Source-based verification (the route without the mathematics, from Unit 9):

I compared each of the eight claims in the summary with the passage it
cites, in the four sources supplied, recording which I could not check.

The first claim the sources did not support was claim 2, which gives 19.6
percentage points where Source B, p. 94, says approximately 20; I recorded
it as over-specified and corrected the claim to what the source states.

Each names a specification. Each names a check. Each names what it showed. Each names a discrepancy and its resolution. And all three point at something a reader can check for themselves. That is what makes them defences rather than assertions.

3. The disclosure

A disclosure is short, factual, and about process: the smaller half, and the easy one. It carries three things:

1. What you used AI assistance for — drafting, translating, reviewing, debugging, explaining, summarising.
2. At which stage — first draft, revision, checking, or throughout.
3. What you did about it afterwards — how the output was verified, and what you changed.

The required detail depends on the context. Follow the applicable institutional, assessment, publication, or workplace rule. A tool and version can be useful for reproducibility, terms-of-service review, or incident investigation, although the name alone says little about what happened. Record it when required or materially useful, together with the scope and stage of use.

Reusable template

Copy this, delete what does not apply, and keep it to two or three sentences.

AI-use disclosure
-----------------
AI assistance was used to <what: draft / translate / review / debug / explain>
<which part of the work> at the <stage> stage.

The output was <not used verbatim / revised after verification / used verbatim
after checking>. Specifically: <what you changed and why>.

All <values / claims / code> were verified by <table-based comparison against a
reference I derived / running the course's checker / consulting the cited
source>, and I am responsible for the final content.

<Tool and version, when required or materially useful.>

Professional code-review disclosure

The same structure can be used outside coursework. For example, a code review or design note can record what was generated, how it was checked, and who is taking responsibility for the final change.

## AI Assistance Disclosure
- **Scope:** AI assistance used for an initial draft of `bernoulli.py`.
- **System:** <tool, model/version, and date, when required or useful>.
- **Prompt record:** [full prompt, or a link/hash to the retained prompt].
- **Verification:** 
  - Code audited for untrusted imports and security risks.
  - Tests run against the reference oracle.
  - Edge cases checked: `B1 = -1/2`, exact `Fraction` returns, odd terms above
    `B1`, and the large-index case `B30`.
- **Evidence:** <link to the retained test output or review record>.
- **Accountability:** <named person or role> reviewed and accepted the change.

Worked academic example

AI-use disclosure
-----------------
AI assistance was used to draft the initial version of the bernoulli() routine
in section 3, at the first-draft stage.

The output was revised after verification: the first version used the second
Bernoulli convention (B1 = +1/2) and returned floats. I re-specified the
requirement and replaced it.

All returned values were verified against the course's oracle
for every n from 0 to 30, and I am responsible for the final content.

Notice what the disclosure does not do. It does not argue that the routine is correct. It reports that verification happened, which a reader has to take on trust; the defence and its certificate are what let them check.

Rules about disclosure can change. A publisher, journal, institution or employer may ask for an AI-use statement in its own format, and may change that format; check the current version of whatever applies to you rather than any summary, including this one.

What a disclosure can and cannot do

One more thing about disclosure, and it is the sort of thing this course would be inconsistent to leave out.

A disclosure cannot be confirmed from the finished work. Nobody can establish, by inspecting a finished piece, that the disclosure attached to it is complete or that its absence is a lie. Text does not carry a reliable mark of how it was made. As of 2026, the tools sold as detectors do not settle it either: they return likelihoods over surface features, they can be wrong in both directions, and being wrong in the direction of accusing someone is a serious thing to be wrong about. Provenance labels do not settle it in general. As of 2026, signed content credentials [V1, secs. 1.1, 1.3], [V2, secs. 6.1, 7.2.2-7.2.3] and invisible watermarks [V3, pp. 818, 823], [V4, "Watermark application", "Limitations"] can mark output from the generators that take part in a scheme. But a credential records where a file came from, not whether it is true, and it can be stripped; a text watermark marks only the output of providers that apply one, and rewriting or translation weakens its detection. A label that is present tells you that a participating tool marked the file; one that is absent tells you nothing. Records outside the work, such as retained conversations, drafts or production logs, may corroborate parts of a disclosure, or contradict them, without proving that the account is complete.

Both directions of detector error matter. A false negative passes generated text as human; a false positive flags honest writing as generated. The false positives need not fall evenly: one 2023 study of seven detectors found them falling on essays by non-native English writers [V5, Fig. 1]. And base rates work against the accuser. If most of the writing being screened is human-written, even a low false-positive rate, applied to many honest writers, produces many false accusations: if one honest essay in a hundred were flagged, a thousand honest essays would yield about ten. The lab's exercise 5 makes the same point in code: a test that wrongly rejects the correct implementation is reported as a failure, because a test that fails good code is worse than no test. A detector that flags honest writers is that test, with a person on the receiving end.

Follow that where it goes. A disclosure is not a control. It records something that no inspection of the finished work can confirm, so nothing should be designed as though it could — and a rule that depends on inspecting the finished work for undisclosed use is asking for evidence the work does not contain. If a piece of work genuinely has to be produced without AI assistance, that condition has to be created by the setting it is produced in, not asserted by a rule about the artefact afterwards.

So what does carry the weight? Two things, and both can actually be established:

• The work. Whether a claim is correct is checkable, by the methods this whole course is about, and a certificate lets someone else check it too. That does not depend on how the work was made, which is why the check is worth more than the declaration.
• Who is answerable. If you put your name to something, you are answerable for it being right, and that holds whether a model drafted it, a colleague drafted it, or you wrote every word. Assistance does not move responsibility, and no disclosure removes it.

None of which makes disclosure optional. You still owe a reader an honest account of how work was made, and in many settings you are required to give one. The point is narrower and worth being exact about: disclosure is a duty you owe, and the finished work cannot confirm it. Treat it as the easy half, and put your effort into the half that can be checked.

This course is its own example. Its videos tell you they are narrated by synthetic voices, and its front page says it was made by AI systems working with a person who reviews it. You cannot confirm either statement from the course itself, and neither would tell you whether the course is right if you could. What you can check is the oracle against published tables, the citations against their sources, and the Note G facsimile against Unit 16's reading of it. The same goes for the completion record the progress page prints: any name can be typed into it, and it records what one browser marked as done. It is a declaration with a heading. Your evidence pack, if you build it well, is the opposite: plain, and checkable.

None of this is new

Ghost-writing, uncredited help, copied text and claims of sole authorship that nobody could verify all existed long before AI, and so did confident errors in human work: Note G itself went to press with mistakes in it. A declaration of how work was made could never be confirmed from the work alone, and human authorship never guaranteed correctness. What generative AI changes is mostly speed and volume. Plausible text and code now cost seconds, while checking still takes as long as it always did. Slowing down to check is not distrust of AI; it is how any source, tool or colleague's work is used responsibly, and the cheaper the output, the more that discipline matters.

4. The evidence pack

The pack is yours. It is a private formative self-check: you are not asked to submit it, it is not marked, and nobody collects it. Export it or show it to someone only if you decide to. Build it, though, as if you might: so that a reader who does not take your word for anything could still check your claim from what is in it. That is what turns a folder of notes into a certificate.

You have already produced most of this without being asked to collect it.

The structure and the completion criteria are in Learner evidence template. Use that file as the container; this page only explains items 7 to 9. Item 9 is one artefact from your own work: the eleventh row of your Unit 3 activity, the thing you use an AI system for, planned through the same method in the activity's Task 4.

The pack works identically from any of the three ways of verifying. A pack built on table-based verification is complete, a pack built on the checker is complete, and a pack built on source-based verification is complete. What is being evidenced is the same thing: that you established what correct looked like, compared against it, found the disagreement, and can say what you did.

If you took the Python route, you can export your self-check record:

python3 selfcheck.py progress --evidence

That prints a Markdown table you can paste straight into the pack. A fresh record, run on 2 November 2026, reports "Passed 0 of 39 checkpoints." and lists every checkpoint with whether you passed it and how many attempts you made. Thirty-nine is every checkpoint in the course: Unit 8 has alternatives by route and shorter routes have fewer, so a finished record need not read 39 of 39. Read the note the tool prints underneath it: the record shows which checkpoints you passed, and is not a claim that you can defend the answers. Nor is it a certificate: it is a local record that you could edit, and nobody else can check it. An AI system can help draft a defence, but it cannot supply evidence that was never gathered or accept accountability on your behalf. You must check the statement against your record and be able to support it yourself.

5. Where the boundary is

Do not paste confidential, personal, or assessment-restricted material, or other people's unpublished work, into an AI system.

Four short reasons, one per category. Confidential material is not yours to disclose. Personal data about other people is not yours to send. Other people's unpublished work, including their drafts, is not yours to circulate; your own is yours to decide. And some assessed material you are simply not permitted to share, whatever your own view of the risk.

Unit 13 teaches this boundary rather than only signposting it: what leaves your device, what is retained, and how to work with material you are not free to share. Some things this course does not teach: sustainability beyond the resource section in Unit 4, and industry practice. For both there are general starting points, not rules that bind you: on the energy and environmental footprint of AI, the International Energy Agency's Energy and AI [L19], a measurement of what using different kinds of model costs [L20], and the OECD's account of what should be measured [L21]; on how organisations govern and deploy AI, NIST's AI Risk Management Framework [L22] and its profile for generative AI [L23], and the OECD AI Principles [L24]. Nor does it state institutional policy, employer policy or legal advice for your jurisdiction, and nothing in it settles them; where one of them applies to you, find out its current rules from whoever sets them.

Rules about AI use in assessed work

The rules for AI use in assessed work are set by your own institution or programme, not by this course. Find out what they are before you use AI in a piece of assessed work.

6. Ada's claim, read carefully

In Note G, writing about the Analytical Engine, Lovelace stated that it "has no pretensions whatever to originate any thing" (Lovelace 1843, Note G — full entry in References and source policy).

The sentence gets quoted a great deal in discussions of AI, usually as a settled verdict. It is worth slowing down, because there are two easy readings and both are wrong.

The first easy reading: she settled it, and language models therefore originate nothing. But consider what she was describing. The Analytical Engine would execute a procedure specified completely in advance, operation by operation. Every quantity it would handle was named beforehand. A system trained on a large corpus is not in that position: it produces combinations its authors did not write and could not have predicted in advance, and the specification of its behaviour is nothing like a Note G table. Her sentence describes the machine she was writing about; whether even that is right is part of what Turing answered [T14, sec. 6]. Extending it to a different kind of system is an argument that has to be made, not a quotation that can be deployed.

The second easy reading: she was writing about clockwork, so the remark is obsolete. But this treats "originate" as though its meaning were obvious. It is not. If origination requires intention, or understanding, or a purpose held by the thing doing it, then producing a novel combination is not sufficient and her claim survives intact. If origination just means producing something that did not exist before and was not specified in advance, then the question turns on facts about what these systems produce. Both positions are held by serious people. This course does not resolve it, and you should be suspicious of any short treatment that does — including a confident one you might be handed by a language model, which will produce a well-turned answer to a question its own output cannot settle.

What it does do is show where the disagreement lies. "Originate" has four main readings, and they lead to different verdicts:

• Novelty, producing what nobody specified. Turing took up "Lady Lovelace's Objection" by name in 1950 and replied, among other things, that machines often take us by surprise [T14, sec. 6].
• Creativity, which Margaret Boden's account takes to need something new, surprising and valuable, made by combining ideas, exploring a space of them or transforming that space [T15].
• Understanding, grasping meaning and not only form. This is the philosophical question whether a system understands, a different question from the working sense in section 1. Searle argued that running a program is not sufficient for understanding [T16]; Bender and Koller that a system trained only on the form of language has no way to learn its meaning [L13, p. 5185].
• Consciousness or intention, something experienced or meant. There is no single agreed theory: the research draws on several theories of consciousness, which differ [L14, p. 4].

Each reading can be made more concrete, and then part of the question can be tested. Novelty can be checked by comparing what a system produces with what it was trained on, where that can be searched; where it cannot, the comparison cannot be made. Understanding taken as behaviour (whether output predicts, explains and carries an idea to new cases) can be tested on what a system produces; passing such tests is evidence about the output; whether it amounts to understanding in the philosophical sense is the open question taken up below. Understanding taken as meaning is an argument about what training on text can give, and the tests above do not settle it. Consciousness can be made concrete only through a theory: one 2023 assessment took indicator properties from scientific theories of consciousness, and its analysis suggested that no current AI system was conscious and that there was no obvious technical barrier to building one that met the indicators [L14, p. 1]. That answer is only as good as the theories, and they disagree. So making the notions concrete does not end the debate; it moves it to which notion of originating should matter, and why.

She also wrote that the Engine can do "whatever we know how to order it to perform" [P2, p. 722]. So her sentence still prompts a useful accountability question: who specified, used, reviewed, and approved the result? For your own submission, you remain answerable for using generated material. In a modern organisation, responsibility can also be shared among users, reviewers, deployers, employers and vendors. AI assistance does not remove your responsibility, and the course does not claim that nobody else has duties.

Three words without agreed definitions

Much of the public argument about AI turns on three words: understanding, intelligence and consciousness. None has an agreed definition. That is the first thing to notice when a claim uses one of them, because a claim that does not say which sense it means cannot be checked.

Understanding, and the Chinese Room. Searle imagined himself alone in a room, following a program for responding to Chinese characters. He understands no Chinese, yet the replies he passes out lead those outside to think a Chinese speaker is inside. A computer running a program does only what he does, so, he concluded, running a program cannot by itself give understanding: syntax (the form of symbols and the rules for handling them) is not sufficient for semantics (what they mean) [T16].

The best-known reply is the systems reply. It grants that the man does not understand Chinese, but argues that he is one part of a larger system (the man, the program, the paper, the room), as a processor is one part of a computer, and that the system as a whole does understand. On this reply, the argument examines only a part [T21, sec. 4.1]. Searle answered that the man could memorise the program and do everything in his head: he would then be the entire system, and would still not understand Chinese [T16, "The systems reply"]. Critics reply that this examines a part again: what runs in his head may be a second system, "much more like a case of multiple personality" than the man himself coming to understand [T21, sec. 4.1].

A second criticism concerns what Searle offers instead. He does not claim that no machine could think: brains, he says, are machines, and brains think [T21, sec. 3]. His own view concerns intentionality, the property of being about something, which he sees as a causal power of the brain produced by biological processes [T16]. Critics answer that he does not say what those powers are precisely enough to tell whether anything else could have them; one, Gardiner, holds (in the encyclopedia's summary) that Searle owes a more precise account of intentionality than he has given [T21, sec. 5.2].

This course's working account of understanding (section 1) is about your own model of what you work with: whether it keeps corresponding to its target under checks. It is not an answer to Searle's question, which is whether running a program, however well its output fits, gives understanding at all [T16]. After four decades of replies there is "still no consensus as to whether the argument is sound" [T21, "Conclusion"]. You may find either side persuasive. What you cannot do is cite the Chinese Room, or a reply to it, as if it settled whether a particular system understands.

Intelligence. The word in "artificial intelligence" has no agreed definition either. Legg and Hutter collected some seventy informal definitions, from dictionaries, psychologists and AI researchers; one of them, from a psychologist, reads in full "Intelligence is what is measured by intelligence tests" [T17, secs. 1-4]. They did not conclude that intelligence cannot be defined: they found common features (an agent, a goal, adapting across environments) and adopted "Intelligence measures an agent's ability to achieve goals in a wide range of environments", while granting that it is hard to argue that any one definition is objectively the correct one [T17, sec. 5]. Turing, earlier, had set the question of thinking aside and replaced it with a test of behaviour [T14, sec. 1]. Chollet argues that skill at a task falls short of measuring intelligence, because prior knowledge built in by the developers, or enough training data, can buy skill without any ability to handle what was not anticipated; a program that hard-codes an engineer's solution shows the engineer's intelligence, not its own. He proposes to measure intelligence as the efficiency of acquiring new skills over a stated scope of tasks, given what the system started with, and does not claim that this is the one true definition [T18, secs. II.1.1, II.2.1].

That bears directly on claims you will read: that a model is "more intelligent" than another, "human-level", or "artificial general intelligence". Ask whether such a claim rests on any measurement and, if so, what was measured. The questions are the ones this course asks of every output: in what sense, measured how, on which cases, with what was already in the system's training data?

Consciousness. Here the disagreement starts at the definition: the words "conscious" and "consciousness" are used "in a wide range of ways with no privileged or canonical meaning" [T22, sec. 2.3]. One influential criterion is Nagel's: a being is conscious if there is something it is like to be it [T19]. Chalmers named the hard problem: giving an intelligible account of how experience could arise from physical processes at all [T20, sec. 2]. Theories differ on what consciousness is; among them [T22, secs. 2.2, 8.1-8.2, 9.1, 9.5-9.7]:

• functionalist theories make a state conscious by the role it plays;
• global workspace theories make information conscious, at least in what is called the access sense (available for use in thought and action, whether or not anything is felt), by its being available to a workspace that many processes can use;
• higher-order theories make a state conscious by the system's representing its own state;
• integrated information theory identifies consciousness with a kind of integrated information that comes in degrees;
• neural theories tie it to particular processes in brains.

Illusionism answers the hard problem differently: it holds that phenomenal consciousness, in the philosophers' sense (what an experience is like from the inside), is an introspective illusion, because introspection, looking inward at your own experience, misrepresents experiences as having phenomenal properties. On this view there are still experiences, and a form of consciousness is accepted; experiences seem to have phenomenal properties, and those properties do not exist [T23, secs. 1.1, 1.6].

This course takes a position on method, not on what consciousness is:

1. There is no agreed definition and no agreed theory. Indicators have to come from some theory: the assessment above took its indicators from several [L14, p. 4].
2. What a system says about itself is more output. "I am conscious" and "I am not conscious" are both text a model trained on human writing can produce, so neither settles anything by itself. Even a model's displayed step-by-step explanation of its answer need not reflect what drove the answer [L9, sec. 3.2].
3. So "this AI is conscious" and "no AI could ever be conscious" are both claims nobody can check as stated. Ask which theory, which indicators, and what evidence.
4. Your accountability does not wait for the answer. Whoever submits the work answers for it, whatever helped produce it.

Nothing in this course's method depends on settling any of these three questions. Checking asks what a claim says and what evidence supports it, and that works the same whether or not the system that produced the claim understands, is intelligent, or is conscious. The words matter where they are used to claim something: to give credit, to excuse a failure, or to sell a product. There, ask which sense is meant.

7. What you can now do

• Distinguish an ordered procedure from statistically generated continuation, and say why the difference changes how you check the output.
• Establish a reference independently of a produced value before trusting that value, and explain why that order matters.
• Verify by table-based comparison or by automated checker, and name the specific failure mode rather than reporting "it is wrong".
• Turn a failure you have observed into a specification clause that prevents it.
• Write a defence that rests on evidence another person can check rather than on authority, and a disclosure that reports how the work was made.
• State the scope and limits of that evidence, and retain ownership of the final claim.
• And, if you took Unit 16 on the complete route: sort a claim into established, contested, or unsourced, and say what evidence would move it.

The closing standard is not "I generated this and disclosed it." It is "I understand the claim, I gathered independent evidence appropriate to it, I can hand over that evidence so someone else can check it, I can defend its scoped correctness, and I take ownership of using it." Disclosure belongs alongside that standard for transparency; it does not satisfy it, and the finished work cannot confirm it. "I understand the claim" is not a feeling: it means you can predict relevant behaviour, explain the transformation at the level the claim needs, name an independent check, and interpret a failed one.

If you take one habit forward, ask what independent evidence supports the result and whether you understand it well enough to defend the claim within that evidence's limits. Record how it was made as a separate transparency statement. When deciding what still needs checking, sort each claim by its status: established (you can name the source you looked at), contested (sources disagree, or one account was copied forward without a check) or unsourced (no source you can name yet). Unit 16, on the complete route, works through these three.

A note on the general case

The split between the two statements is an instance of something wider. Disclosure carries provenance — where the thing came from; a defence carries warrant — the evidence, and the specification the evidence was gathered against. A candidate answer is not warranted merely by fluent writing or honest provenance. Its support must be appropriate to the claim and separable from the assertion being checked. The course's closing Unit 18 interprets that distinction through the second-order material set out in Second-Order Reasoning: The Lens Behind The Course; neither this page, the evidence pack, nor cp17-disclosure depends on it.

This is practical. The course's checker computes its verdict from outputs compared with a separately established oracle; the routine's own docstring cannot make it pass. Its output is a certificate: you can rerun it without trusting the routine, its author, or this course. In research or professional review, the corresponding support might be a measurement, a primary source, an independently implemented method, or review by someone qualified and accountable. The form changes with the claim; the principle does not.

Checkpoints

Assemble your evidence pack first — the checkpoints are easier and considerably more meaningful once you have written a real defence rather than imagined one.

python3 selfcheck.py run cp17-disclosure
python3 selfcheck.py run cp17-scope-the-claim  # or in the browser

Both routes ask the same questions and give the same diagnostics.