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:
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:
That pause is the human check. Suggest is fine; act without reading is how unread code causes real problems.
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.
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:
After each reveal, name who was responsible.
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.
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.
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.
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:
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?
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.
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.
Capture the finished list (photo of the board, shared doc, or platform note). You will need it again when students choose their CBA approach.
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.