Not recorded yet. The lesson below is complete and runnable today — the video is added later without touching this page.
recordings/F2.2.mp4"We only deployed it, we didn't build it" — sometimes true, often not.
Risk classification, GPAI obligations, transparency duties, and how agentic deployment changes classification.
Classify three workflows and defend the boundary cases.
Horizontal AI regulation applies to you regardless of sector, and its obligations are structural: risk management, documentation, oversight. Those are programme requirements, not paperwork requirements.
The four specific things that move a deployer into a provider's obligations, each of which an engineering team does without thinking of it as a regulatory event — and the show-me test for turning prose requirements into controls.
"We only deployed it, we didn't build it" is sometimes true and often not, and the answer changes what you owe.
Resolve each regulatory theme down to a control from your own catalogue and let its evidence be the answer.
Themes with a control and an artefact behind them. Oversight is the hardest, because the action completes before a human sees it.
Measure this
| what to measure | denominator or target |
|---|---|
| horizontal themes with a control and an artefact behind them | share of themes; oversight is the hardest because the action completes before a human sees it |
horizontal obligations are structural, not clerical risk management system -> you need a register and a tiering model technical documentation -> generated, not written once human oversight -> a named person with real authority accuracy / robustness -> measured, with the method recorded post-market monitoring -> drift detection, by another name
Horizontal AI regulation is, in practice, mostly about documented process and human oversight. That is good news, because those map onto controls you can build and evidence mechanically.
The trap is answering a clause with a policy document. "We maintain appropriate human oversight" satisfies nobody who asks the follow-up question, and the follow-up question is always the same: show me.
So the working method is to resolve each regulatory theme down to a control from your own catalogue (F1.4), and let the control's evidence be the answer. Four themes cover most of it:
Each one resolves to controls you already built in tracks A, B and D.
Anchor → F1.1. Horizontal regulation asks whether a system is robust, overseen and documented. Each of those becomes a different indicator, and agentic deployment changes which one is hardest — oversight, because the action completes before a human sees it.
The skill maps four regulatory themes onto named controls, each with a concrete artefact you could hand over.
Then it applies the show-me test to the prose your policy offers today. The test is one question per sentence: if somebody asked me to show them this, what would I show them?
It counts how many sentences survive. The count is usually lower than people expect.
The skill — skills/regulatory/horizontal-requirement-to-control/SKILL.md
name: horizontal-requirement-to-control
description: >-
Turn horizontal AI-regulation themes into named controls with concrete
evidence artefacts, and apply the show-me test to the prose answers a policy
currently offers. Use when a regulation is being answered with paragraphs.
allowed-tools: Read, Grep, GlobHorizontal AI regulation resolves to a small number of recurring themes — risk management, data governance, human oversight, record keeping, transparency, accuracy and robustness. Each maps to controls you can operate. A policy that answers them in prose passes reading and fails the first follow-up, which is always "show me".
Responding to a horizontal AI regulation, and auditing an existing response before somebody external does.
1 — Extract the themes rather than the article numbers. Article numbers change between drafts and jurisdictions; the themes are stable and map to controls you already have.
2 — Map each theme to named controls from your catalogue. If a theme has no control, that is the finding — record it as a gap rather than writing a paragraph.
3 — Attach the evidence artefact per control. The specific thing that would be handed over: a log export, a test result, an approval record, a signed attestation.
4 — Apply the show-me test to the current prose answers. For each sentence, is there an artefact behind it? Count the sentences that survive. It is usually none, and the count is more persuasive than the argument.
5 — Check freshness. An artefact older than the control's freshness window evidences the past. Report themes as fully evidenced, stale, or unevidenced — three states, not two.
Input — the fixture committed at the top of scripts/horizontal_requirement_to_control.py. Edit it and re-run: the buckets, counts and verdicts below are derived from it, not hard-coded.
Output — the opening lines of a real run:
risk management system
AC-1 agent identities distinct from human and separately revocable
evidence: gateway logs with an act chain; monthly sample
SB-2 privileged tools require approval below L3
evidence: tool policy in git + denial log
DR-1 behavioural drift raises an alert
evidence: drift alerts and dispositionsThe run continues past this. test_skills.py executes the script on every build, with no model configured — so what CI proves is that it runs and refuses legibly, not that it prints these lines. The output above is a recorded run against a real model, and nothing re-diffs it: a model's answer is not reproducible, and this repository does not claim otherwise anywhere it can be checked.
{
"themes": [{"theme": "str", "controls": ["str"], "gap": false}],
"evidence": [{"control": "str", "artefact": "str", "as_of": "str", "fresh": true}],
"prose_answers": [{"text": "str", "survives_show_me": false}],
"status": [{"theme": "str", "state": "evidenced|stale|unevidenced"}]
}Three ways to do this lesson. Pick one. They run the same procedure against the same code — what changes is who drives it, and how much you see.
The agent reads the lesson, explains the idea, fetches the code, runs the check and answers your questions as you go. This is the one to take if you are here to learn.
Install it, once. From the folder you cloned. --all does every agent it finds on your machine:
python3 scripts/install_skills.py --all --lessons F2.2Then restart your agent and open it in that folder. On Windows, if python3 says Python was not found, use python instead.
Then pick f2-2-horizontal-ai-regulation:
| agent | install just for this agent | start it |
|---|---|---|
| Claude Code | python3 scripts/install_skills.py --tool claude --lessons F2.2 | type /f2-2-horizontal-ai-regulation |
| GitHub Copilot (VS Code) | python3 scripts/install_skills.py --tool copilot --lessons F2.2 | type /f2-2-horizontal-ai-regulation in Chat |
| Cursor | python3 scripts/install_skills.py --tool cursor --lessons F2.2 | type / in Agent chat and search for it |
| Codex | python3 scripts/install_skills.py --tool agents --lessons F2.2 | type $f2-2-horizontal-ai-regulation, or run /skills |
No agent, no conversation. The same lesson executes and prints the same readback. Take this one if you have no assistant, if you are reviewing rather than learning, or if you want the result without the teaching around it.
python3 scripts/lesson.py F2.2Neither of the above, and no model needed. The first command writes CyberTravels exactly as it stood at the end of this lesson; the second prints the diff — the lines this lesson added or changed, and nothing from any later one.
python3 scripts/checkpoint.py --at F2.2 --out work/cybertravels
python3 scripts/checkpoint.py --at F2.2 --diffOn Windows, type python wherever these say python3 — and use \ instead of / in the paths. Everything else is identical. A0.0 step 2 explains why.
Ways 1 and 2 need a model; way 3 does not. A signed-in Claude Code CLI needs no API key, and any OpenAI-compatible endpoint works too. With neither, the audit exits 2 and says so rather than inventing an answer. A0.0 sets this up.
Ways 1 and 2 both end with the same readback: What I did, What changed, The number and Read this next. A step that was skipped or refused is reported as exactly that, never as a pass.
If you did the last lesson’s challenge, expect this to stop. Most challenges ask you to edit the code, and ways 1 and 2 will not overwrite your edits: you get stopped, not a failure, with two options — --out for a fresh folder that keeps your work, or --force to discard it and start this lesson clean.
Four regulatory themes resolve to named controls, each with a concrete evidence artefact. All four prose answers fail the show-me test. Checking freshness, two themes are fully evidenced — human oversight fails on a stale SB-2 and risk management on a failing DR-1 — giving a smaller but defensible statement.
Take one clause your programme claims to satisfy and trace it to an artefact with a date. If the trail ends at a policy document, the clause is ticked and undefended.
Skill source: skills/regulatory/horizontal-requirement-to-control