Unit 8: Disclosure, defence, and responsible use

Reading time: about 17 minutes. Activity: about 10 minutes. Course items: 6 and 8, with light 3 and 7. Checkpoint: cp08-disclosure. Before this unit: Unit 6 (re-prompting and specification). Unit 7 (historical honesty) is optional 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. Unit 9 closes the module afterwards by naming the general question all of this has been circling.

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.

They are separate statements, they answer different questions, and neither one substitutes for the other.

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 failure runs the other way too. Work you can defend in complete detail, with the assistance undeclared, is not rescued by being correct. The reader needed to know how it was made in order to know what to check — and to know how much of your judgement is behind it.

Two statements, two questions — but they do not carry equal weight.

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 and reproduce what the thing does: your model of it maps its behaviour, and you have checked that the map holds — for which the verification lab gathers evidence. 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. The module's authors mapped the as-printed Note G table well enough to predict what it computes — 139/630, not the number the web repeats (course/historical-notes.md §4): a perfect map of a wrong table. Understanding without a correctness check is not yet a defence; disclosure without either is not a defence at all.

So disclose, always, and without shame — then spend your effort on the defence. It 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, identify 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 disclosure

A disclosure is short, factual, and about process. 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 module'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 stable 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 module oracle for n = 0 to 20 and
for n = 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. That is a different sentence, and it comes next.

3. The defence

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 module has been circling since Unit 3.

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 varies by model, task, prompting method, and distribution [L4]. This module 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. 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.

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

Both routes produce a real defence

These routes have equal standing in this module, 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), verified by comparing B0 to B8 term by term against the values I
derived from the recurrence by hand, which agreed at every index.

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 6 for
n = 0 to 20 and n = 30; the checker reported no divergence over those inputs.

The discrepancy I found was float output at higher indices, reported as
`not-fraction`, which I resolved by requiring exact Fraction returns.

Both name a specification. Both name a check. Both name what it showed. Both name a discrepancy and its resolution. That is what makes them defences rather than assertions.

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.

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

The structure and the completion criteria are in course/learner-evidence-template.md. Use that file as the container; this page only explains items 7 and 8.

The pack works identically from either route. A pack built on table-based verification is complete, and a pack built on the checker 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. 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. 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, unpublished, or assessment-restricted material 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. Unpublished work is not yours to circulate, and that includes other people's drafts. And some assessed material you are simply not permitted to share, whatever your own view of the risk.

This module signposts that boundary rather than teaching it. Privacy — and sustainability alongside it — is covered properly by wider course Item 5; see course/course-map.md for the item list and this module's coverage level.

Rules about AI use in assessed work

Whether AI assistance is permitted in a particular piece of assessed work, and in what form, is set by your own institution or course. This module does not set those rules and does not state them. Follow whatever your institution says, and ask your tutor if you are unsure.

6. Ada's claim, read carefully

In Note G, writing about the Analytical Engine, Lovelace stated that it "has no pretensions whatever to originate anything" (Lovelace 1843, Note G — full entry in course/references.md).

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, by her, 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 was exactly true of the thing in front of her. 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 module 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.

Her sentence still prompts a useful accountability question: who specified, deployed, used, reviewed, and approved the result? For a student's own submission, the student remains 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 the learner's responsibility, but the module does not claim that no one else has duties.

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.
• Derive a reference value before trusting a produced one, and explain why that order cannot be reversed.
• 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 disclosure that reports how work was made, and a defence that rests on evidence rather than on authority.
• State the scope and limits of that evidence, and retain ownership of the final claim.
• And, if you did the optional Unit 7: 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 defend its scoped correctness, and I take ownership of using it." Disclosure belongs alongside that standard for transparency; it does not satisfy it.

8. Where this connects

This module leads on some course items and only touches others. The canonical list of items, names, and coverage levels is course/course-map.md — this page does not restate them.

• The items this module covers strongly are the ones you have just been doing: evaluating outputs, critical thinking, academic integrity, and effective use in computing.
• The items it touches lightly — responsible AI and professional practice — are represented here only by the parts the Ada and Bernoulli example naturally supports: accountability, disclosure, and a review-style workflow.
• Item 5 is signposted only. Nothing on this page is a substitute for it.

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. If you also did optional Unit 7, use its three claim-status buckets when deciding what still needs checking.

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 module's closing Unit 9 interprets that distinction through the second-order material set out in course/second-order.md; neither this page, the evidence pack, nor cp08-disclosure depends on it.

This is practical. The module's checker computes its verdict from outputs compared with a separately established oracle; the routine's own docstring cannot make it pass. 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.

Checkpoint

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

python3 selfcheck.py run cp08-disclosure     # or use the browser self-check

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