What regulation asks of an engineer
Risk tiers that follow a system's use, the requirements for high-risk systems as artifacts an engineer builds, evidence tied to a model version, a model card a program can check, and legal dates kept as data.
What it covers7
Why it matters
Rules for AI systems are now law in some places and policy in most large companies. An engineer doesn't need to be a lawyer, and shouldn't play one. But nearly everything these rules ask for is something an engineer builds: an evaluation, a log, a datasheet, an approval step, a document that matches the system. If those exist and are current, compliance is mostly a matter of pointing at them. If they don't, no lawyer can write them afterward. This lesson is about the engineer's half. It is not legal advice.
What you'll be able to do
- Sort an AI system into a risk tier, and say why the tier depends on its use and not its technology
- List what a high-risk system must have, and name the engineering artifact behind each requirement
- Check that the evidence for each requirement exists and describes the version being shipped
- Keep a model card whose claims a program can test against the latest measurements
- Treat legal dates and thresholds as data with a source, since they change
Show the answer
Differently: the rules follow what the system is used for
The obligations attach mainly to the use. Ranking job applicants affects people's livelihoods and sits in a listed high-risk area, so it carries heavy requirements. Suggesting recipes carries almost none. The model underneath is the same, and its maker has separate duties of its own.
The idea: risk decides the rules
The tiers decide which duties apply, and the sorting is a short chain of yes-or-no tests. The check below recalls how a datasheet documents a dataset, since each requirement turns into an artifact like it.
Risk decides the rules
The most detailed law so far is the European Union's AI Act, in force since August 2024 and applying in stages. It reaches any system used in the EU, wherever its builder is. Other places have different rules, and most follow the same idea: the more harm a use could do, the more is required.
The Act sorts uses into tiers.
- Prohibited. A short list of practices that may not be done at all, such as social scoring, or reading employees' emotions at work.
- High-risk. Systems that affect decisions about people in listed areas: hiring, education, credit, essential services, law enforcement, and a few more. Allowed, with heavy requirements.
- Transparency duties. Systems that talk to people must say they are AI, and synthetic media must be marked.
- Minimal. Everything else, which is most things.
The cell is a sketch of that sorting, simple enough to read. The real test is the legal text, applied with a lawyer.
PROHIBITED = {
"social scoring", "emotion recognition at work or school",
"scraping faces to build a recognition database",
}
HIGH_RISK_AREAS = {
"hiring and workers", "education", "credit and insurance",
"essential public services", "law enforcement", "migration and borders", "courts",
"critical infrastructure",
}
def tier(system):
"""A teaching sketch of the EU AI Act's tiers. The real test is the legal text,
read with a lawyer."""
if system.get("practice") in PROHIBITED:
return "prohibited"
if system.get(
"area"
) in HIGH_RISK_AREAS and system.get("affects_decisions_about_people"):
return "high-risk"
if system.get("talks_to_people") or system.get("makes_synthetic_media"):
return "transparency duties"
return "minimal"
systems = [
{"name": "spam filter for a mail app"},
{"name": "customer support chatbot", "talks_to_people": True},
{
"name": "CV screening that ranks applicants", "area": "hiring and workers",
"affects_decisions_about_people": True, "talks_to_people": True,
},
{
"name": "loan approval score", "area": "credit and insurance",
"affects_decisions_about_people": True,
},
{
"name": "essay grader for a school", "area": "education",
"affects_decisions_about_people": True,
},
{
"name": "timetable planner for a school", "area": "education",
"affects_decisions_about_people": False,
},
{"name": "product photo generator", "makes_synthetic_media": True},
{
"name": "mood tracker for call-center staff",
"practice": "emotion recognition at work or school",
"area": "hiring and workers", "affects_decisions_about_people": True,
},
{"name": "enemy behavior in a video game"},
]
counts = {}
for system in systems:
t = tier(system)
counts[t] = counts.get(t, 0) + 1
print(t.ljust(19), "|", system["name"])
print(counts)Nine systems: three minimal, two with transparency duties, three high-risk, one prohibited.
Look at the two school systems. An essay grader is high-risk. A timetable planner in the same school is minimal, since it doesn't affect a decision about a person. The technology could be identical. And the mood tracker shows the order of the checks: a prohibited practice stays prohibited whatever else is true of the system.
Two roles matter. The provider builds a system and puts it on the market. The deployer uses it in its own work. Most duties fall on the provider. A company that builds a hiring tool on another company's model is the provider of the hiring tool. Makers of general-purpose models have a separate set of duties, mostly about documentation.
Show the answer
The startup, which built the hiring product and sells it
The high-risk system is the hiring product, and the startup is the one that built it and put it on the market. Using someone else's model doesn't move that duty. The model's maker has its own obligations as a provider of a general-purpose model, and the employers have lighter ones as deployers, such as using the tool as instructed and keeping a person in the loop.
Use Back and Next. The checks run in this order, and a prohibited practice stays prohibited.
Write a sentence or two, then compare it with a good answer in the lesson.
In code: dates as data, evidence that must match the version
Every cell here is plain Python: dates compared as strings, a repository checked against a list, and a model card whose claims a program can test.
Which rules apply on this day?
Legal dates change, so keep them as data. Write in_force(rules, day). rules is a list of (start, name) pairs, with start a date written as "YYYY-MM-DD". Return the names of the rules that have started on or before day (also "YYYY-MM-DD"), ordered by start date, earliest first, and by name where two start together. Dates in this format compare correctly as plain strings.
def in_force(rules, day): return [] rules = [ ("2027-12-02", "high-risk requirements"), ("2025-02-02", "prohibited practices"), ("2025-08-02", "general-purpose model duties"), ] print(in_force(rules, "2026-11-10"))
What high-risk asks for, in an engineer's words
For a high-risk system the Act lists requirements. Read as an engineer, each is something you have already built in this course.
| Requirement | What it means | The artifact |
|---|---|---|
| Risk management | Find the ways it can harm, reduce them, and keep doing so | A risk register, red-team results |
| Data governance | Know your data: source, quality, gaps, bias | A datasheet, quality checks |
| Technical documentation | Describe the system well enough to assess it | A model card, a system description |
| Record-keeping | Log what it did, automatically | Traces and logs |
| Information for users | Tell the deployer how to use it and what it can't do | Instructions for use |
| Human oversight | A person can understand, intervene and override | An approval step, an override procedure |
| Accuracy, robustness, security | It works, keeps working, and resists attack | Evaluations, monitoring, red-team results |
Around these sit a quality system, an assessment before launch, monitoring after it, and reports of serious incidents. The penalties are sized to be noticed: for the worst breaches, up to 7% of a company's worldwide yearly turnover.
Having an artifact once is not enough. It has to describe the version being shipped. The cell checks a repository against the list.
# what a high-risk system must have, and the artifacts that would show it OBLIGATIONS = [ ("risk management", ["risk register", "red-team report"]), ("data governance", ["datasheet", "data quality report"]), ("technical documentation", ["model card", "system description"]), ("record-keeping", ["trace logs"]), ("information for users", ["instructions for use"]), ("human oversight", ["approval step", "override procedure"]), ( "accuracy, robustness, security", ["evaluation report", "red-team report", "monitoring"] ), ] def coverage(obligations, repo, current): """For each obligation: 'ok', or what is missing or out of date. repo maps an artifact to the model version it describes.""" report = {} for name, artifacts in obligations: missing = [a for a in artifacts if a not in repo] stale = [a for a in artifacts if a in repo and repo[a] != current] report[ name ] = "ok" if not missing and not stale else {"missing": missing, "stale": stale} return report repo = { # each artifact, and the model version it was last updated for "risk register": "v3", "datasheet": "v3", "data quality report": "v3", "model card": "v2", "system description": "v3", "trace logs": "v3", "approval step": "v3", "evaluation report": "v3", "red-team report": "v1", "monitoring": "v3", } report = coverage(OBLIGATIONS, repo, "v3") for name, status in report.items(): if status == "ok": print(name.ljust(30), "| ok") else: parts = [ kind + ": " + ", ".join(items) for kind, items in status.items() if items ] print(name.ljust(30), "|", "; ".join(parts)) print( "obligations with complete, current evidence:", sum(s == "ok" for s in report.values()), "of", len(report), )
Two of seven requirements have complete, current evidence. Nothing dramatic is wrong. Two documents were never written: instructions for use, and what to do when a person must override the system. Two went stale: the model card still describes version 2, and the red-team report is from version 1, which leaves two requirements uncovered at once.
This is what a compliance gap usually looks like. The system may be perfectly good. Nobody can show it, since the evidence describes a model that no longer runs.
Show the answer
The document that travels with it: what it holds, its gaps and its limits
A datasheet records where a dataset came from, what is in it by column and by group, what is missing, what personal data it holds, and what it should and shouldn't be used for, with claims a program can check. It is exactly the evidence the data governance requirement asks for. If you kept one, that row of the table is already done.
needs = {
"record-keeping": ["logs"], "documentation": ["model card", "system description"],
"oversight": ["approval step"],
}
repo = {
"logs": "v4", "model card": "v3", "system description": "v4", "approval step": "v4",
}
ok = [name for name, artifacts in needs.items()
if all(repo.get(a) == "v4" for a in artifacts)]
print(len(ok), ok)Show the answer
2 ['record-keeping', 'oversight']
Logs and the approval step are both at version 4. Documentation needs two artifacts, and the model card is still at version 3, so that requirement isn't covered even though both files exist. A stale document is treated the same as a missing one: it describes a different system.
What has to be written or updated?
Write evidence_gaps(obligations, repo, current). obligations is a list of (name, artifacts). repo maps each artifact that exists to the version it describes. Return a sorted list of (action, artifact) tuples: ("write", artifact) for an artifact that is missing from the repo, and ("update", artifact) for one whose version isn't current. An artifact needed by several obligations appears once.
def evidence_gaps(obligations, repo, current): return [] obligations = [ ("risk management", ["risk register", "red-team report"]), ("accuracy", ["evaluation report", "red-team report"]), ("oversight", ["override procedure"]), ] repo = {"risk register": "v3", "red-team report": "v1", "evaluation report": "v3"} print(evidence_gaps(obligations, repo, "v3"))
Documents that can be checked
A model card is to a model what a datasheet is to a dataset: what it is for, what it must not be used for, what it was trained on, how well it works, for whom, and where it fails. It is the heart of the technical documentation.
Its weakness is that prose doesn't fail a test. A sentence written for version 2 will still be sitting there at version 5, sounding confident. The cure is the one from Datasheets: write the claims as numbers a program can compare with the latest measurements.
card = { # a model card, written for version 2 and not touched since
"model": "loan-score", "version": "v2",
"intended use": "Rank consumer loan applications for review by a credit officer.",
"out of scope": "Business loans. Decisions without a human reviewer.",
"training data": "Applications from 2019 to 2024. See the datasheet.",
"claims": {
"accuracy": 0.84, "true positive rate gap between groups": 0.03,
"share of applications sent to a human": 1.0,
},
"limitations": "",
}
measured = { # from the latest evaluation of the version that is about to ship
"version": "v3",
"accuracy": 0.842, "true positive rate gap between groups": 0.105,
"share of applications sent to a human": 0.62,
}
REQUIRED = ["intended use", "out of scope", "training data", "claims", "limitations"]
problems = []
if card["version"] != measured["version"]:
problems.append("the card describes " + card["version"]
+ " and the model being shipped is " + measured["version"])
for section in REQUIRED:
if not card.get(section):
problems.append("section is empty: " + section)
for claim, stated in card["claims"].items():
now = measured.get(claim)
if now is None:
problems.append("no measurement for the claim: " + claim)
elif abs(now - stated) > 0.02:
problems.append(
claim + ": the card says " + str(stated) + ", measured " + str(now)
)
for problem in problems:
print("-", problem)
print(
len(problems), "problems. Claims that still hold:",
[c for c, s in card["claims"].items() if abs(measured[c] - s) <= 0.02],
)
Four problems, found in a few lines. The card describes the wrong version. Its limitations section is empty, and that section is the one a deployer most needs.
The last two are the serious ones. The card says the true positive rate differs between groups by 0.03. The latest evaluation says 0.105. And the card promises that every application is sent to a human reviewer. In the system about to ship, 62% are. Someone turned on automatic decisions for the easy cases and nobody updated the card.
That second gap is more than a stale document. The card's "out of scope" section rules out decisions without a human reviewer, and human oversight is one of the requirements. The check has found a change in what the system does. Only one claim still holds: accuracy.
Run a check like this in the release pipeline, beside the tests. Then the document and the system can't drift apart without someone being told.
Show the answer
A requirement may be broken, as well as the card being wrong
Human oversight is a requirement for high-risk systems, and the card's scope ruled out unreviewed decisions. So the mismatch isn't a typo. It says the system's behavior has moved outside what was assessed. The first step is to find out whether automatic decisions are permitted at all, and only then to make the card true again.
Living with rules that move
Law changes slowly and then suddenly. The AI Act's main deadline for high-risk systems was August 2026. An amendment adopted in 2026 moved it to December 2027. Anyone who had typed "August 2026" into a planning document, or into code, was wrong overnight.
So handle legal facts the way you handle prices: as data, with a source and the date you last checked. The table in the cell is how the dates stood when this lesson was last checked. Read the official text before relying on any of them.
from datetime import date # (applies from, what, source and when it was last checked) -- dates in law move: keep # them as data RULES = [ ( date(2025, 2, 2), "prohibited practices are banned", "EU AI Act, checked 2026-11" ), ( date(2025, 8, 2), "duties for providers of general-purpose models", "EU AI Act, checked 2026-11" ), ( date(2027, 12, 2), "requirements for stand-alone high-risk systems", "as amended in 2026 (was 2026-08-02), checked 2026-11" ), ( date(2028, 8, 2), "requirements for high-risk AI inside regulated products", "as amended in 2026 (was 2027-08-02), checked 2026-11" ), ] def in_force(day): return [what for start, what, source in RULES if start <= day] for day in (date(2025, 1, 1), date(2026, 11, 10), date(2028, 1, 1)): print( day, "|", len(in_force(day)), "in force |", "; ".join(in_force(day)) or "none yet", ) launch = date(2027, 6, 1) ahead = [(start, what) for start, what, source in RULES if start > launch] print() print( "a hiring tool launching", launch, "has", (ahead[0][0] - launch).days, "days until:", ahead[0][1], )
On the day this was written, two sets of rules were in force: the bans, and the duties for makers of general-purpose models. The high-risk requirements arrive later. The hiring tool in the last lines launches 184 days before they apply to it. That is no reason to wait: the artifacts take longer than that to build well, and customers ask for them now.
The EU Act is not the only thing an engineer meets.
- The NIST AI Risk Management Framework, from the United States, is voluntary and widely used. It organizes the work under four words: govern, map, measure, manage.
- ISO/IEC 42001 is a standard for how an organization manages AI, which a company can be certified against.
- Laws that already existed still apply: on discrimination, consumer credit, product safety and privacy. European privacy law, for one, gives people rights when a decision about them is made by a machine alone.
They overlap heavily, and all ask the same of an engineer: know what the system is for, measure it, write it down, keep a person able to step in, and keep the evidence current.
deadline = "2027-12-02" for day in ("2027-12-01", "2027-12-02", "2028-01-15", "2027-9-30"): print(day >= deadline, end=" ")
Show the answer
False True True True
With four-digit years and two-digit months and days, strings sort in date order, so the first three comparisons are right. The last one is a trap. "2027-9-30" has no leading zero, and the character "9" sorts after "1", so the string compares as later than December when September is earlier. Dates kept as data need one strict format, or a real date type.
Worked example: is this hiring tool ready to ship?
A team has built a CV-screening product on another company's model. Version 5 is ready. The code works out the tier, checks the repository against the seven requirements, and turns the gaps into a to-do list.
PROHIBITED = {
"social scoring", "emotion recognition at work or school",
"scraping faces to build a recognition database",
}
HIGH_RISK_AREAS = {
"hiring and workers", "education", "credit and insurance",
"essential public services", "law enforcement", "migration and borders", "courts",
"critical infrastructure",
}
def tier(system):
"""A teaching sketch of the EU AI Act's tiers. The real test is the legal text,
read with a lawyer."""
if system.get("practice") in PROHIBITED:
return "prohibited"
if system.get(
"area"
) in HIGH_RISK_AREAS and system.get("affects_decisions_about_people"):
return "high-risk"
if system.get("talks_to_people") or system.get("makes_synthetic_media"):
return "transparency duties"
return "minimal"
# what a high-risk system must have, and the artifacts that would show it
OBLIGATIONS = [
("risk management", ["risk register", "red-team report"]),
("data governance", ["datasheet", "data quality report"]),
("technical documentation", ["model card", "system description"]),
("record-keeping", ["trace logs"]),
("information for users", ["instructions for use"]),
("human oversight", ["approval step", "override procedure"]),
(
"accuracy, robustness, security",
["evaluation report", "red-team report", "monitoring"]
),
]
def coverage(obligations, repo, current):
"""For each obligation: 'ok', or what is missing or out of date. repo maps an
artifact to the model version it describes."""
report = {}
for name, artifacts in obligations:
missing = [a for a in artifacts if a not in repo]
stale = [a for a in artifacts if a in repo and repo[a] != current]
report[
name
] = "ok" if not missing and not stale else {"missing": missing, "stale": stale}
return report
system = {
"name": "CV screening that ranks applicants", "area": "hiring and workers",
"affects_decisions_about_people": True, "talks_to_people": True,
"built on": "another company's model, through its API",
}
repo = {
"risk register": "v5", "datasheet": "v5", "model card": "v5",
"system description": "v5", "trace logs": "v5", "evaluation report": "v5",
"red-team report": "v4", "monitoring": "v5", "approval step": "v5",
}
print("system:", system["name"], "| built on:", system["built on"])
print("tier:", tier(system))
report = coverage(OBLIGATIONS, repo, "v5")
todo = []
for name, status in report.items():
if status != "ok":
todo += [
"write: " + a + " (for " + name + ")" for a in status["missing"]
] + ["update: " + a + " (for " + name + ")" for a in status["stale"]]
print(
"obligations fully evidenced:", sum(s == "ok" for s in report.values()), "of",
len(report),
)
for line in sorted(set(todo)):
print(" ", line)
print("ready to ship:", not todo)The tier comes first, and it is high-risk: hiring is a listed area and the tool affects who gets an interview. That the model belongs to someone else changes nothing about who is responsible for the tool. Then the evidence. Two of seven requirements are fully covered, and the to-do list has five lines, though only four pieces of work: the red-team report is from version 4, and its staleness uncovers two requirements at once. Three documents were never written. None of this says the tool is bad. It says the team can't yet show that it is good, and for a high-risk system that is the same as not ready. Notice how ordinary the list is: a report to rerun, three documents to write. That is what regulation mostly asks of an engineer, and all of it is easier to do as the system is built than the week before launch.
Write a sentence or two, then compare it with a good answer in the lesson.
On the job: a model card, a gap list and a legal calendar
In practice you do not read the law for a living. You keep the evidence current, and you keep the dates as data with a source.
Where it comes up in a week
A customer's procurement team sends a questionnaire: the model card, the datasheet, the red-team report, the logging policy, the oversight procedure. You open the repository and the coverage check lists what is missing or describes an older version. The legal calendar in facts.js says which duties apply on which day, with the source and the date it was last read, so no one plans around a date that moved. Anything the law decides stays with a lawyer; the engineer's part is the evidence.
A model card for the churn model
The churn model (version 4) predicts which subscribers will cancel, ranks them for the retention team and was trained on twelve months of account history. It scores 0.83 accuracy overall and 0.74 for subscribers in their first month. Write its model card in the form a program could check.
It must
- Names the model version and the dataset version
- States results as numbers, overall and for one group
- Names a limit and a human duty
Go further
- Says how the card is checked at release
The template
## Intended use What it is for. ## Out of scope What it must not be used for. ## Training data What it learned from, with the dataset version. ## Results Overall and by group, as numbers. ## Limits Where it is weak, and who must stay in the loop.
Goes deeper in
- Datasheets: the data side of the same evidence.
- A model registry: versions and the artifacts that describe them.
- Red-team lab: the red-team report as evidence.
- Measuring fairness: the audit table as a card section.
Write a sentence or two, then compare it with a good answer in the lesson.
Practice what you just read
- 5 code examples you can edit and run
- a practice exercise that checks your code
- a 5-question quiz
- 13 review cards for spaced repetition
Try a quiz question
What decides which tier of rules an AI system falls under in a risk-based law such as the EU's AI Act?
Before this lesson
Where this lesson leads.
575 lessons in thirteen phases. 176 are free without an account, and a free account opens the rest. See every lesson.
Phase 11 · about 34 hours of study
Professional practice
Design, ship and run real systems, work well in a team, and get hired
43 lessons 1 free
- System design fundamentals FreeRequirements, rough numbers, the standard parts and where systems break.40 min
- Caches, queues and background jobsSpeed reads with caches, and move slow work to queues that retry safely.40 min
- Designing AI systemsLatency, cost, routing, fallbacks and guardrails for features built on models.40 min
- Containers and deploymentPackage an app as an image, configure it with the environment, and roll out safely.45 min
- CI/CD pipelinesTest every change automatically, and ship with gates, flags and rollbacks.40 min
- Docker ComposeSeveral containers together: service names, volumes, secrets and start order.40 min
- Kubernetes basicsDesired state, Deployments and Services, labels, probes and rolling updates.40 min
- Cloud for AI engineersAccess policies and least privilege, storage, compute choices, managed model endpoints, secrets and budgets.30 min
- Metrics, dashboards and alert rulesCounters, gauges and histograms, a rate from a counter, a percentile from buckets, a dashboard panel and an alert rule that fires on a sustained condition.40 min
- Reliability and incidentsSLOs, error budgets, alerts, on-call and blameless postmortems.40 min
- Incident lab: from the page to the postmortemOne incident run from the page to the all-clear: decide the mitigation, work out the impact in failed requests and error budget, and write a blameless postmortem, a status update and a runbook entry.40 min
- Measuring an AI feature from its logsTyped views over event logs, metric specs, cost from a price table, and rollups you can rerun.40 min
- A/B testing a model changeHash assignment, per-user results from raw logs, sample ratio checks, guardrails and a decision rule.40 min
- Columnar files and a local warehouseRows against columns, the encodings that shrink a column, Parquet's row groups and the ranges that let a query skip them, and SQL over files with DuckDB.40 min
- Data quality checks and contractsSix properties of a delivery you can test, each as a count of rows that break it, a contract with the producer, and when to block, quarantine or warn.40 min
- Transformations: staging, models and testsRaw, staging, facts and marts as SQL models run in dependency order in DuckDB, tests as queries that count the rows that break a rule, an incremental load that is safe to rerun, and the same models as dbt files.45 min
- Streams and windowsEvents that never stop arriving: event time against arrival time, tumbling, sliding and session windows, a watermark for late events, and counting each event once.40 min
- Labels and annotator agreementLabels as measurements: agreement and Cohen's kappa, the pair of classes annotators confuse, votes and gold questions, and what wrong labels do to a model and a test score.45 min
- Experiment tracking and reproducible runsA run record of settings, seed, data and code behind every score, a run log in a dozen lines, and comparing settings across seeds.40 min
- Hyperparameter searchWhat a grid costs, random search on a log scale, stopping weak settings early, and why the winner's validation score flatters it.40 min
- Versioning data and modelsFiles stored under the hash of their contents, a manifest that names a whole dataset, and lineage from data and code to each model.35 min
- A model registry and promotionVersions under one name, an alias for the live one, gates a candidate must pass, group by group, and a rollback that moves a pointer.40 min
- Feature pipelines and training-serving skewWhy a model that passes offline fails live: statistics refit at serving, two code paths, and features from the future, with the fix for each.40 min
- Batch and online inferencePredict ahead of time or on request: when the inputs exist, latency near a server's limit, batching what waits, cost, and a hybrid with a freshness limit.40 min
- Monitoring a model: drift and decayWhy a model worsens with no code change: data drift and concept drift, a measure of how far inputs have moved, thresholds set from noise, and labels that arrive late.45 min
- Retraining and pipelinesWhen to retrain and on which weeks, training as steps in dependency order, a cache that reruns only what changed, and guards before and after.45 min
- Designing ML systemsOne method for an ML design, goal and metric to retraining, with the sums that size it: requests a second at peak, a year of feature storage, a label delay and a latency budget.45 min
- Datasheets: documenting a datasetThe document that travels with a dataset: a profile by column and by group, claims a program can check, splits that don't leak, a scan for personal data, and the license and limits only people can write.45 min
- Curation, active learning and synthetic dataThree levers on a training set: removing copies and broken rows, letting a model choose which rows to label, and manufacturing rows, which helps only when their source knows more than you do.45 min
- Measuring fairnessBreak a model's results down by group: selection rate, true and false positive rates and precision, why they can't all be equal, what each fix costs, and when a group is too small to judge.40 min
- Privacy engineeringWhy removing names isn't anonymity, how to hold less (minimization, retention, keyed pseudonyms), the idea behind differential privacy and its budget, what a model remembers, and a deletion that reaches every store.40 min
- A red-team labAttack a simulated assistant methodically: eight kinds of attack run as a suite, success rates beside ordinary requests blocked, fresh attacks to test the fixes, where a defense belongs, and findings kept as release tests.45 min
- What regulation asks of an engineerRisk tiers that follow a system's use, the requirements for high-risk systems as artifacts an engineer builds, evidence tied to a model version, a model card a program can check, and legal dates kept as data.35 min
- Git for teamsBranches, pull requests, rebasing and how a three-way merge finds conflicts.40 min
- Writing for engineersREADMEs, design docs, commit messages and bug reports people can act on.35 min
- Scoping and estimating workA vague request cut into tickets with acceptance criteria and a first shippable slice, estimates as ranges, an honest update for a slip, and a ticket linked to its pull request.30 min
- Roles, résumé and the searchWhat AI, ML and data engineering postings ask for, résumé bullets that carry a number, a 100-word project summary, a take-home as a portfolio piece and how to read an offer.35 min
- Interviews and your portfolioShow your work, and solve interview problems the way professionals do.40 min
- Code reviewWhat to look for, how to give and take feedback, and automating the routine checks.35 min
- Reading unfamiliar codeFind your way around a big codebase fast, with tools that map it for you.35 min
- Working with AI coding toolsGive agents good context, keep tasks small, and check every change they make.35 min
- Capstone: ship a production AI serviceAn AI-backed service with validation, caching, rate limits, fallbacks, logging and evals.45 min
- Capstone: take a model to productionA churn model through a data contract, a tracked run, a registry gate by slice, hybrid serving, a PSI monitor and one retrain, shipped with a datasheet, a model card, a fairness audit, a design doc and a runbook.45 min
Never trained an AI? Teach a small one to write, right in your browser. It takes about 20 seconds and needs no account. Teach it to write