Chapter 2 · Lab

Lab: What is Artificial Intelligence?

Run this lab

Edit and run the chapter code

Choose an available implementation, change the code, then run it here or continue in the dedicated Labs workspace.

ai_system_classifier.py

"""Describe AI systems on six axes, check the descriptions, and price the
authority decision.

Part 1  Four real systems described on six axes from their public
        documentation. Authority is recorded as the effects the application
        lets an output have, and mapped to the Sheridan-Verplank scale.
Part 2  Consistency checks for the category errors the chapter warns about,
        including the one behind Moffatt v. Air Canada (2024).
Part 3  The review decision for a customer-service assistant: expected monthly
        cost of no review, full review and risk-routed review across error
        rates, and the error rates at which the cheapest policy changes.

Standard library only and deterministic; java/AiSystemClassifier.java prints
byte-identical output.
"""

import math

# effect -> (authority level, Sheridan-Verplank level)
EFFECTS = {
    "display": ("inform", "2-3"),
    "suggest": ("recommend", "4"),
    "prepare": ("draft", "5"),
    "state_policy": ("execute: a statement the company must honour", "7"),
    "act_reversible": ("execute, reversible", "7-8"),
    "act": ("execute", "9-10"),
}
ORDER = ["display", "suggest", "prepare", "state_policy", "act_reversible", "act"]

SYSTEMS = [
    {
        "name": "Gmail spam filtering",
        "field": "AI: natural language processing",
        "method": ["machine learning"],
        "family": "neural text classifier (RETVec vectorizer, 2023)",
        "capability": ["classify"],
        "application": "email client",
        "effects": ["act_reversible"],
        "controls": ["user can move mail back", "spam folder visible"],
    },
    {
        "name": "GitHub Copilot inline suggestions",
        "field": "AI: code generation",
        "method": ["machine learning"],
        "family": "large language model",
        "capability": ["generate"],
        "application": "code editor",
        "effects": ["display", "prepare"],
        "controls": ["human approval"],
    },
    {
        "name": "Waymo Driver",
        "field": "AI: robotics and perception",
        "method": ["machine learning", "planning", "rules"],
        "family": "neural networks for perception and prediction",
        "capability": ["perceive", "predict", "plan", "act"],
        "application": "ride-hailing",
        "effects": ["act"],
        "controls": ["operational design domain", "remote advice, never remote driving"],
    },
    {
        "name": "Air Canada website chatbot (2022)",
        "field": "not disclosed",
        "method": ["not disclosed"],
        "family": "not disclosed",
        "capability": ["answer questions"],
        "application": "airline customer service",
        "effects": ["display", "state_policy"],
        "controls": ["link to policy page"],
    },
    {
        "name": "Refund bot (a flawed proposal)",
        "field": "AI",
        "method": ["prompting"],
        "family": "Generative AI",
        "capability": ["generate", "act"],
        "application": "customer refunds",
        "effects": ["state_policy", "act"],
        "controls": ["monitoring"],
    },
]

def authority(effects):
    top = max(effects, key=ORDER.index)
    return EFFECTS[top]

def check(system):
    problems = []
    if system["family"] == "Generative AI":
        problems.append("'Generative AI' is a capability, not a model family")
    if "large language model" in system["family"] and "machine learning" not in system["method"]:
        problems.append("an LLM is a learned model, so the method must include machine learning")
    if "act" in system["effects"] and not {"human approval", "rollback", "operational design domain"} & set(system["controls"]):
        problems.append("irreversible action with no approval step, rollback or operating envelope")
    if "state_policy" in system["effects"] and not {"answers quote canonical policy", "human approval"} & set(system["controls"]):
        problems.append("customer-facing policy statements bind the company; ground them in the canonical policy or route them to a person")
    return problems

def six_axes():
    print("=== Parts 1 and 2: Five systems on six axes, with consistency checks ===")
    for system in SYSTEMS:
        level, scale = authority(system["effects"])
        print(system["name"])
        print(f"  field        {system['field']}")
        print(f"  method       {', '.join(system['method'])}")
        print(f"  model family {system['family']}")
        print(f"  capability   {', '.join(system['capability'])}")
        print(f"  application  {system['application']}")
        print(f"  authority    {level}; Sheridan-Verplank level {scale}")
        print(f"  effects      {', '.join(system['effects'])}")
        problems = check(system)
        if not problems:
            print("  checks       consistent")
        for problem in problems:
            print(f"  CHECK FAILED {problem}")

# --- Part 3: the review decision ------------------------------------------------------------

CONVERSATIONS = 100_000   # per month (illustrative)
RELIED_ON = 0.10          # share of wrong policy answers a customer acts on (illustrative)
ERROR_COST = 812.02       # C$ per relied-upon wrong answer: the Moffatt v. Air Canada award
REVIEW_MINUTES = 1.5      # per reviewed conversation (illustrative)
WAGE = 40.0               # C$ per reviewer hour (illustrative)
CATCH = 0.90              # share of wrong answers a reviewer catches (illustrative)
ROUTED = 0.10             # share of conversations routed to review: refunds and policy exceptions
ROUTED_ERRORS = 0.80      # share of costly wrong answers that fall in routed conversations

def whole(value):
    """Round half up to a whole number, identically in Python and Java."""
    return int(math.floor(value + 0.5))

def policy_costs(error_rate):
    per_review = REVIEW_MINUTES / 60 * WAGE
    expected_errors = CONVERSATIONS * error_rate * RELIED_ON * ERROR_COST
    none = expected_errors
    full = CONVERSATIONS * per_review + expected_errors * (1 - CATCH)
    routed = CONVERSATIONS * ROUTED * per_review + expected_errors * (1 - CATCH * ROUTED_ERRORS)
    return none, full, routed

def review_decision():
    print("=== Part 3: Expected monthly cost of three review policies (C$) ===")
    print(f"{CONVERSATIONS:,} conversations a month; {RELIED_ON:.0%} of wrong answers acted on at "
          f"C${ERROR_COST:,.2f} each; review {REVIEW_MINUTES} min at C${WAGE:.0f}/h catching {CATCH:.0%}.")
    print("error rate      no review    full review   risk-routed   cheapest")
    names = ("no review", "full review", "risk-routed")
    for rate in (0.001, 0.005, 0.01, 0.02, 0.05, 0.08):
        costs = policy_costs(rate)
        cheapest = names[costs.index(min(costs))]
        print(f"{rate * 100:>9.1f}%   {whole(costs[0]):>11,}   {whole(costs[1]):>11,}   "
              f"{whole(costs[2]):>11,}   {cheapest}")
    per_review = REVIEW_MINUTES / 60 * WAGE
    unit = RELIED_ON * ERROR_COST * CATCH
    full_vs_none = per_review / unit
    routed_vs_none = ROUTED * per_review / (unit * ROUTED_ERRORS)
    full_vs_routed = (1 - ROUTED) * per_review / (unit * (1 - ROUTED_ERRORS))
    print(f"Full review beats no review above an error rate of {full_vs_none * 100:.2f}%.")
    print(f"Risk-routed review beats no review above {routed_vs_none * 100:.2f}%, "
          f"and full review beats risk-routed above {full_vs_routed * 100:.2f}%.")

def main():
    six_axes()
    print()
    review_decision()

if __name__ == "__main__":
    main()

Output

Run the code to see output here.

Lab 1 - Define, Describe and Grant Authority

Lab Brief

Difficulty: Beginner Estimated time: 75 minutes Lab ID: VOL1-SEC1-CH2-LAB1

Objective

Decide which of six systems count as AI under three different definitions, describe two systems on the six axes with the chapter's program, place their authority on the Sheridan–Verplank scale, and produce a costed recommendation for how much authority a customer-service assistant should have, including the evidence needed before it can have more.

Everything runs offline with examples/ai_system_classifier.py (standard-library Python) or java/AiSystemClassifier.java (JDK 21), plus the calculator in Figure 2.2.

Scenario

Your company sells a subscription product and wants an assistant on its help page. Product management calls it "our AI agent" and proposes that it answer questions, change subscription plans and issue refunds up to $150 without human involvement. Legal has asked whether the EU AI Act applies to the company's software, and finance wants to know whether reviewing the assistant's answers is worth paying for. You have been asked for a two-page brief.

Tasks

Task 1 - Three definitions, six systems

For each system, answer three questions: is it AI in the research tradition, is it an AI system under the EU AI Act as the Commission's February 2025 guidelines read it, and could a vendor honestly market it as AI?

a chess engine using minimax search and a hand-written evaluation function;
a tax calculator applying 2,000 hand-written rules;
a spam classifier retrained weekly on reported messages;
a gradient-boosted model that scores loan applications;
a route planner that solves a mathematical optimisation problem each morning;
the proposed help-page assistant, built on a large language model.

Justify each legal answer by quoting the part of Article 3(1), Recital 12 or the guidelines you relied on. Mark any answer you are unsure of as uncertain and say what fact would settle it.

Task 2 - Six-axis profiles

Add two profiles to SYSTEMS in the program: the help-page assistant as product management proposes it, and a version you would recommend.
For each, list the effects its outputs may have (display, suggest, prepare, state_policy, act_reversible, act) and the controls you would put in place.
Run the program. The proposed version should fail at least one check. Make your recommended version pass every check, and write one sentence per control saying what would have to be built to make it true.

Task 3 - Authority by category

Split the assistant's work into at least four categories, such as answering general product questions, explaining the refund policy, changing a plan and issuing a refund. For each category, record:

whether the action is reversible, and at what cost;
how quickly a mistake would be noticed, and by whom;
the authority you would grant (inform, recommend, draft, decide or execute) and its Sheridan–Verplank level.

At least one category must be at draft authority and one at execute. Explain the difference using the Air Canada case.

Task 4 - Price the review policy

In Figure 2.2, enter your own estimates for the rates, keeping the C$812.02 award as the cost per relied-upon error unless you have a better figure. Record the cost of each policy and both flip points.
Repeat with the cost per error doubled, with the reviewer catch rate cut to 70%, and with routing that concentrates only 30% of costly errors. Which change moves the decision most?
Change ERROR_COST, CATCH and ROUTED_ERRORS in the program to the same values and confirm it prints the same flip points.
Compute how many consecutive correct answers you would need, at 95% confidence, before choosing "no review" for your baseline assumptions.

Deliverables

The Task 1 table with a quoted justification for every legal answer.
The program output for your two profiles, and the list of controls with what each requires.
The authority-by-category table from Task 3.
The cost comparison, sensitivity results and evidence count from Task 4.
A two-page brief that answers legal, finance and product management in plain language.

Verification

Run the Python and Java versions after adding your profiles and compare their outputs; they should differ only if you edited one and not the other.
Recompute one policy cost by hand with the chapter's formulas and check it against the calculator.
Ask a colleague to read your six-axis profiles without the chapter and say what each system may do to a customer. If they cannot, the authority row is not clear enough.

Success Criteria

Every system in Task 1 has an answer under each definition, and the minimax chess engine is treated differently by the research field and by the Commission's guidelines.
The proposed assistant fails the consistency checks and your recommended one passes, with a concrete build item behind each control.
Refunds do not start at execute authority unless your cost model and your error-rate evidence justify it, and the brief says what measurement would move them there.
The brief states both flip points, the assumptions behind them, and the number of clean answers needed before review could be removed.