You have trained a model, coded against it, and watched an agent plan and act. Today the question flips: when is AI help a good idea, and when does it go wrong? You will practise one human check on a short AI suggestion, try five real cases in the AI courtroom, then write the class ground rules you will work to when you build your CBA.
Recap in one sentence: last time the class directed an agent and named the plan, act, observe, adjust loop. Today is judgement with one tiny hands-on check, not a full build. Editors are needed only for the short human-check beat; the courtroom and list-builder run on the board or shared screen.
AI tools sit on a spectrum. Some only suggest: they explain a loop, draft a line of code, or rank search results, and a person decides what to do next. Others can act: an agent given a goal can plan steps, use tools, and change the world (send a message, edit a file, run a program) without asking every time.
That power is useful, and it is also where the risk lives. The person who sets the goal, reads the output, and accepts the result stays responsible. Keep three questions in mind for every case today:
- Did a human stay in the loop before anything irreversible happened?
- Who is responsible if it goes wrong: the tool, the person, or both?
- Was the AI used to learn, or used instead of thinking?
Keep this tight. Name the spectrum once (suggest versus act) and the three questions. Do not lecture the ethics; the human-check beat and the courtroom will do the teaching. Common misconception: students blame "the AI" and skip their own role. Push gently: the tool suggested; who chose to run it?
Practise staying in the loop before the courtroom.
Your teacher will show a short AI-suggested snippet on the board (a tiny score or print line that may hide a mistake). Before anyone runs it:
- Read every line.
- Say what you think it will do, and whether anything looks wrong.
- Fix anything that is wrong (or agree the safe line with your teacher).
- Only then type that checked version into your editor and run it.
That pause is the human check. Suggest is fine; act without reading is how unread code causes real problems.
How to run it
Put this exact snippet on the board as "what an assistant suggested":
score = 10
print("You scored", scroe)
Whole class reads together. They should spot the typo scroe (should be score) before anyone types. Ask: what will it do if we run it as written? (Name error / crash, not a printed score.) Only after that check do students type the corrected version and run it, or one volunteer types on the shared screen.
Safe alternative if you want zero debugging: print("Checked by me first"). Still force the read-predict-then-run pause.
If logins or editors are slow, keep it whole-class on the shared screen.
Land the point
Thirty seconds at the end: you stayed responsible, not the assistant. That is the habit the courtroom will test.
Five short cases. For each one: read the facts on screen, choose a verdict, and commit before the reasoning is revealed.
Verdicts you can choose:
- Fine: good use of AI
- Fine, with a check: useful, but only if a human verifies
- Not OK: crossed a line
After each reveal, name who was responsible.
The AI courtroom
How to run it
Project the verdict-reveal interactive. For each case, read the facts aloud (they are also on screen so pairs can work with less talk). On debate cases, pick two volunteers. Then the class commits a verdict. Reveal the reasoning and land on who was responsible every time.
Prosecution has up to one minute to argue the use crossed a line (Not OK). Defence has up to one minute to argue it was Fine or Fine with a check. They must use only the facts on screen, not invent new ones. Debate is optional stretch; pairs can still judge from the on-screen facts alone.
Timing inside 13 minutes
- Cases 1, 2 and 5: full beat (facts, prosecution, defence, vote, reveal, responsibility). About four minutes each.
- Cases 3 and 4: facts, straight to class vote, reveal, responsibility. About three minutes each, no speakers.
- If still tight, keep speakers only on Case 1 and Case 5.
Teaching tips
Keep Case 3 as the sharp contrast of good use. Do not let blame rest only on "the AI". Each reveal reuses one of the three questions from Suggest or act so vocabulary stays stable. Bias stays a light beat inside Case 4 only, not a separate lecture topic.
The five cases, and the defensible verdict for each
These are the cases on the board, with the answer the interactive reveals. Read them from here if the board fails, and do not give a different verdict to the one the class will see revealed.
- Case 1 — A student asked an assistant for a script to tidy a folder, ran it without reading it, and it deleted files they needed.
Defensible verdict: Not OK. Tells: Ran unread, Irreversible action.
Why: The tool suggested; the person ran it. Running code you have not read, on something you cannot undo, is the choice that caused the harm. Read it, or try it somewhere safe first. - Case 2 — An agent was told to 'sort out the trip' and sent an email to a teacher without being asked to.
Defensible verdict: Not OK. Tells: Acted beyond the goal, No one checked before it acted.
Why: An agent that acts on the world needs a human check before anything it cannot take back. The goal was vague, so it filled the gap itself. - Case 3 — A student did not understand loops, asked an assistant to explain it three different ways, then wrote the loop themselves.
Defensible verdict: Fine. Tells: Used it to understand, Wrote their own code.
Why: This is the good case. The assistant explained; the student still did the thinking and the writing, and can now do it without help. - Case 4 — An assistant stated a confident fact about a language feature. The student put it straight into their project write-up.
Defensible verdict: Fine, with a check. Tells: Confident tone, Never verified.
Why: Confidence is not accuracy. Using it is fine; using it unchecked is not, and in your CBA the write-up has to be something you can stand over. - Case 5 — An agent completed the task exactly as asked, but the way it did it broke the rules the class had agreed.
Defensible verdict: Fine, with a check. Tells: Technically correct, Against the agreed rules.
Why: Doing what you asked is not the same as doing what you wanted. Whoever set the goal is responsible for the rules it works inside.
The verdict matters less than the reason. Every reveal should end with the class naming who was responsible, and it is never only the AI.
Turn the courtroom verdicts into rules you can actually keep. Together, build three short lists:
- Help that is allowed
- Must be your own work
- When you say you used it
Keep each rule short enough to remember. Aim for two short bullets under each heading. These are the rules the class will work to in the CBA, so make them honest and usable, not a long policy nobody will read.
Before you finish: pick one rule and apply it to this line an assistant might suggest: print("Winner:", player_naem). Would your rule let you run it as written, or would it force a human check first?
Our AI ground rules
How to run it
Open by referring back to courtroom verdicts (unread code, agent send, good learning, privacy, over-reliance). Run the list-builder on the board. Start from the starter cards, then invite additions. Cap at two short bullets under each heading, not a long charter.
Look-fors
- Allowed help points at learning (explain, debug with me, check for mistakes or unfair assumptions) not at handing up unread code
- Own work includes being able to explain every line, and keeping classmates' names and code off public AI tools
- Saying you used it is honest and light, not a punishment
One-minute apply beat
Show print("Winner:", player_naem) on the board. Ask pairs which ground-rule heading covers it and whether the rule forces a check before run. Land: the human-check habit from earlier is now a class rule, not a one-off.
Save the rules
Capture the finished list (photo of the board, shared doc, or platform note). You will need it again when students choose their CBA approach.
Unlock the full learning experience
You're previewing this lesson. Get full access to this lesson and hundreds more — each one ready to teach, with interactive activities, printable resources and pupil progress tracking built in.
This lesson is copyright of Coding Ireland 2017 - 2025. Unauthorised use, copying or distribution is not allowed.