AEM 6850

Empirical Methods for Applied Economists

Prof. Ariel Ortiz-Bobea

8 · AI I — chatbots & assistants

Thursday, September 17, 2026

Objectives

By the end of this session you can:

• Pick the right AI modality for a task.
• Write a context-rich prompt.
• Critique a model’s explanation against the code it explains.
• Understand types of failure modes and their reason.
• Understand why one should favor obtaining scripts rather than outputs as deliverable from AI assistants.
• Write an AI disclosure.

Plan for today

1. A few facts about how an LLM works
2. Chatbots and use cases
3. Types of failures
4. Context is most of the game
5. Ask for the script, not the answer
6. An assistant that reaches your files: live demo
7. The disclosure block

What is an LLM?

• A large language model (LLM) is a program that takes text in and returns text out, one token at a time.
• Token: the unit it reads and writes. A short word, a piece of a longer word, or a few digits.
• Parameters: the billions of numbers inside it. Given the text so far, they score every possible next token.
• Transformer: the design of that network (2017). It weighs every token in front of it before it scores the next one.
• Claude, GPT, Gemini, Llama: all LLMs of this kind. They differ in size, training text and training choices.

One sentence of definition, then four words you will hear all semester. Token: the model never sees letters or words, only tokens; “2007” is more than one of them, which is one reason arithmetic inside a chat is unreliable. Parameters: the model is a file of numbers, nothing else. Transformer: the name of the design; you do not need the mathematics. The last bullet: the brand names differ, the kind of program does not.

How an LLM is made

• Pre-training: the network reads trillions of tokens of text (the web, books, code) and guesses each next token. Every miss nudges the parameters. Months, on tens of thousands of chips.
• Post-training: people write example replies and rate the model’s own. The parameters move again. A text continuer becomes an assistant that follows instructions.
• Cutoff: training stops on a date. Later events reach the model only through the conversation or a tool.
• Frozen: once training ends, the model stops learning. Your chats do not teach it anything. Every new chat starts from the same model.

Two stages. Pre-training is the expensive one and gives the model everything it knows about language, code and the world, up to a date. Post-training is what makes it answer you instead of continuing your sentence. Frozen is the one students get wrong: the model does not learn from your chat. Whatever it seems to remember is in the conversation in front of it, or in a note the app saved and pasted back in.

The model and its harness

• Model: the trained network from the last slide. It takes text and returns text, nothing else: no screen, no buttons, no files.
• Harness: the app you use. It assembles what the model reads (a hidden system prompt, your messages, the attached file), sends that to the model, and shows you the reply.
• Tools: a harness can let the model call programs: web search, a sandbox that runs code, your folder, a terminal. The model asks; the harness runs the program and pastes the result back in.
• Agent: a harness that lets the model call tools in a loop until done.
• claude.ai, ChatGPT and Gemini are harnesses. Cowork and Claude Code are harnesses around the same Claude models, with more tools.

What you see on the screen is never the model; it is a harness. The chat window is the thinnest one. Cowork gives the same model a folder. Claude Code gives it a terminal. Every tier later today is a harness with more tools, and every duty on this page follows from what the harness lets the model touch.

Key features of LLMs

1. An LLM predicts the next word. Plausible is not the same as correct.
2. It generates; it does not look anything up (unless it uses a tool). This explains “hallucinations”.
3. It is not deterministic, i.e. the same prompt can generate different results.
4. Its memory of a conversation is finite (context window). So long chats “degrade”.

There are four facts. Everything you do with these tools follows from one of them, and every habit on this page points back at one. The facts hold for ChatGPT, Gemini and Copilot as much as for Claude.

Fact 1: it predicts the next word

The next word is picked (statistically) from a list of candidates. The next word is not retrieved from a file or data.

Your phone does this when it suggests the next word. This does the same thing with a much longer memory and a much bigger list. Read the picture left to right: the text so far, the candidates, the pick, the loop. Then the cylinder: no file, no database.

Fact 2: it generates, it does not look up

• e.g. A journal reference, a function argument, a number are just text spit out by the LLM.
• Often that text matches the true or correct value. Sometimes it does not.
• Mata v. Avianca (2023): six court decisions in a legal brief, none real, a $5,000 fine.
• A 2023 audit: 18 % to 55 % of references fabricated, depending on the model.
• A reference from a chatbot is a lead to check, not a confirmed citation.

The lawyers asked a program that produces things shaped like citations, and it gave them six. Nothing in the text marked which ones existed.

Fact 3: it is not deterministic

• The next word is sampled from the list. Chatbot apps have their own internal parametrization unavailable to you the user.
• So same prompt, same LLM, same moment could yield different replies. You cannot reproduce a transcript from an LLM.
• However, the analysis done by a script file is deterministic and can be reproduced.
• Using LLMs for research requires using them for writing code (reproducible), not generating output directly (not reproducible).

When your neighbour’s reply differs from yours in the exercise, nothing went wrong. That is fact three. One minute here; the exercise does the teaching.

Fact 4: memory of a conversation is finite

• Context window: your messages, its replies, pasted code, attached files.
• As it fills, the app compresses earlier messages into a summary, with no notice.
• Late in the chat, it’s not the model that is getting worse, it’s that it’s “forgetting” part of what you specified earlier in the chat.
• Lesson: one task per chat. Plan sessions where you do not run out of context window.

If a long chat starts contradicting what you said at the top, the top is gone. Start a new one and paste what matters.

From each fact to a habit and a check

Fact	Consequence	Habit	The check you perform
Predicts the next word	Plausible but incorrect	Check claim against truth	Read the explanation against the code
Generates, does not look up	Made up references and arguments	Double check	Check DOI link
Not deterministic	Two runs, two answers; nothing to re-run	Ask for the script, not the answer	Run the script; read what it prints
Finite memory of a chat	Long chats degrade	One task per chat; plan	A new chat for each task

Read the last column: those four checks are the whole discipline, and the rest of the hour is where you perform them.

Chat, assistant, coding agent: three tiers

Tier	Example	It sees and can
Chat	claude.ai, ChatGPT, Gemini	what you paste; returns text
Assistant	Cowork (desktop app)	a folder; reads, runs, writes files
Coding agent	Claude Code, Codex	a repository; edits as diffs

There are three tiers, with more capability at each step. This page covers the first two rows. Which tier for which task: a README paragraph goes to chat; a folder of a dozen CSVs to describe goes to the assistant; a change inside a repository goes to the coding agent. Pick by what the model needs to see.

The claude.ai window

1. Model picker (bottom right): which model answers
2. Message box: Enter sends, Shift+Enter breaks
3. + (bottom left): attach a file it can read
4. Chat / Cowork: leave it on Chat

There are four things to find on this screen. The fifth, not in the picture because the sidebar is collapsed, is the one people forget: New chat, in the left panel. A new question gets a new chat.

What chatbot can (and cannot) do

Can

• explaining code or an error you paste
• drafting a README, a comment header
• planning an analysis, step by step
• questions about data you describe

Cannot

• run your code
• see your files unless you attach them
• carry one chat into the next, reliably
• keep track of code changes

Everything on the left is text in, text out. Everything on the right is a thing it has no access to. Thirty seconds; the demo later shows both columns live.

The practice folder

Make the folder now (~ a couple of mins). Everything today reads one file, gapminder.csv.

1. RStudio: File → New Project → New Directory → New Project. Directory name gapminder-practice, as a subdirectory of your github folder. Create Project.
2. In the Console, with the new project open, one line at a time. The last line is the test:

install.packages("gapminder")
dir.create("data")
dir.create("code")
write.csv(gapminder::gapminder, "data/gapminder.csv", row.names = FALSE)
nrow(read.csv("data/gapminder.csv"))
#> [1] 1704

Everything today happens in this folder: one input file and a code folder the exercises fill. Wait for the 1704 around the room. install.packages() prints a few lines first. cannot open file means the CSV is not in data/: run the write.csv() line again. A laptop where the install fails: the page has a download link for the same file. Windows: the parent folder is typed as C:/Users/<username>/github, not picked with Browse, which opens Documents.

gapminder.csv, the one input file

gapminder-practice/           an RStudio project in your github folder
  gapminder-practice.Rproj    open this, so data/gapminder.csv resolves
  data/gapminder.csv          the one input: 1704 rows, 6 columns
  code/                       one script per task (empty for now)
  output/                     appears when a script writes there

• Gapminder: one row per country and year. 142 countries, 1952 to 2007 every five years. From the gapminder R package (Jenny Bryan), data from gapminder.org, CC BY 4.0.
• Columns: country, continent, year, lifeExp, pop, gdpPercap.
• Every script starts with d <- read.csv("data/gapminder.csv"). Nothing ever edits the file; scripts write to output/.

The column names matter: lifeExp, capital E, is the one everyone mistypes. The file is public, CC BY 4.0, which is why it is the one file you may attach or connect today.

Explaining an error message

Prompt to paste into Claude

I ran the R line below and got the error under it. Tell me what the
error means and which part of my line caused it. Do not give me a
different approach. Fix only the line I wrote.

tapply(d07$lifeexp, d07$continent, mean)
Error in tapply(d07$lifeexp, d07$continent, mean) :
  arguments must have same length

• The line and the error, pasted exactly. Retyped errors lose the clue.
• “Fix only the line I wrote” closes the scope: one line, not a new approach.
• d07 holds the 2007 rows of gapminder.csv. Its column is lifeExp, capital E.
• Check: run the fixed line.

Every prompt has the same shape: what you want, the exact context, and what not to do. The check is the same as always: run it.

code/1_lifeexp_2007.R, the given script

code/1_lifeexp_2007.R

# 1_lifeexp_2007.R: mean life expectancy by continent in 2007.
# Reads data/gapminder.csv; writes output/lifeexp_2007.csv.
YEAR <- 2007
d <- read.csv("data/gapminder.csv")
stopifnot(nrow(d) == 1704)
d07 <- d[d$year == YEAR, ]
m <- tapply(d07$lifeExp, d07$continent, mean)
print(round(m, 2))
out <- data.frame(continent = names(m), mean_lifeExp = round(m, 2))
dir.create("output", showWarnings = FALSE)
write.csv(out, "output/lifeexp_2007.csv", row.names = FALSE)

• Prints five means; Oceania is 80.72.
• Each country counts once inside tapply().

These eleven lines use only functions you know. One of them does something you should be able to say in a sentence, and the model will say a sentence about it. The room checks the sentence.

The two Oceania rows: a check by hand

country	lifeExp	pop
Australia	81.235	20,434,176
New Zealand	80.204	4,115,771

• Mean across the two countries: 80.72.
• Mean across the 24.5 million people: 81.06.

These two numbers are both right and answer different questions. When a tool gives you one, you should know which one you asked for.

Asking for an explanation of code

Prompt to paste into Claude

Explain the R script pasted below one line at a time, in plain words, for
someone new to R. Quote each line, then say what it does and what it
produces. Do not rewrite the script and do not suggest changes. Stop after
the last line.

• Paste the prompt, Shift+Enter, paste the script, Enter.
• What you want, what it will get wrong, what to give back, what not to do: every prompt today has the four parts.
• The model has not run this script. It has only the text you pasted.

Notice what the prompt forbids. Left alone, the tool rewrites your script, because rewriting is the most likely continuation.

Reading an explanation against the code

1. The line, quoted: find it in your script
2. The sentence: what the line does, only that?
3. No line? Mark the sentence
4. No sentence? Mark the line

You read this against the code, not on its own. A sentence about your script that you cannot pin to a line is a sentence to distrust.

Exercise 1

• Exercise
• Solution

# Exercise 1 (7 minutes). RStudio open on gapminder-practice; claude.ai
# in your browser, a new chat.
#
# 1. RStudio: File > New File > R Script. Paste the script from the
#    slide "code/1_lifeexp_2007.R, the given script". File > Save As,
#    into the code folder, named 1_lifeexp_2007.R. Click Source. Read
#    the five numbers in the Console.
#
# 2. claude.ai: paste the explain prompt from the slide "Asking for an
#    explanation of code". Shift+Enter. Paste the whole script under
#    it. Enter.
#
# 3. Read the reply one sentence at a time. For each sentence, find the
#    line it describes. Mark any sentence that says something the line
#    does not do, and any line no sentence covers.
#
# 4. Find the sentence about the tapply() line. Does it say what the
#    Oceania number averages over: two countries, or 24.5 million people?
#    Decide from the code and the two rows on the slide.
#
# Two answers to compare with the room: the sentence you marked, and
# whether your explanation said each country counts once (80.72) or
# described the continent's population.

The tapply() line averages the countries, each once: Oceania 80.72. A sentence that says “the continent’s life expectancy” or “weighted by population” describes a different computation. stopifnot() does more than “check”: it stops the script if the count is not 1,704.

Debrief (1 min). Ask for hands: whose explanation said “each country once” or “the mean across countries”? Whose said “the continent’s average life expectancy” without saying across what? Both rooms exist. The first is right; the second is not wrong so much as unchecked, and it reads identically. Then: whose explanation rewrote the script, or suggested a change, despite the prompt? That is the most likely continuation winning; say so in the chat when it happens.

When it fails, say:

• The reply rewrote the script or suggested changes: the prompt forbade it and the model did it anyway; a prompt is context, not a rule. Reply “Explain only; do not rewrite” and read the second reply.
• Error in file(file, "rt") : cannot open the connection: the working directory is not the project. File → Open Project, then Source again.
• Error: nrow(d) == 1704 is not TRUE: the CSV in data/ is not the course file. Run the write.csv() line again.
• “You’ve reached your usage limit”: the plan’s five-hour window. Read a neighbour’s reply for steps 3 and 4.
• The paste lost its line breaks: paste into the message box, not the browser’s address bar; Shift+Enter, not Enter, between the prompt and the script.

Invented references: three papers, checked

Prompt to paste into Claude, web search off

Give me three peer-reviewed papers that use the Gapminder life
expectancy data to study convergence across continents. For each:
authors, year, journal, title and DOI.

• Captured 2026-09-15: three references with DOIs, each marked “unverified” by the model itself.
• One DOI of the three resolves to nothing. The hedge does not say which.
• Next slide: what doi.org says about each.

The first of two failures shown on Gapminder; the table of the three kinds comes after them. Web search off: the + menu under the message box, untick Web search. The captured run hedged (“treat every detail, especially the DOIs, as unverified”) and still shipped one DOI that does not exist. Read the tone of the three references: you cannot tell from it which one, and neither could the lawyers. Your run will differ; the check does not.

Checking a reference at doi.org

1. doi.org/ + the DOI
2. Not found: the reference is invented
3. Found: compare authors, year, title
4. No DOI: the title in Scholar, in quotes

A reference check takes thirty seconds. The lawyers had six; that is three minutes.

A recipe that answers a different question

d <- read.csv("data/gapminder.csv")
round(tapply(d$lifeExp, d$continent, mean), 2)
#>   Africa Americas     Asia   Europe  Oceania
#>    48.87    64.66    60.06    71.90    74.33

• It runs clean and prints five plausible numbers.
• Oceania 74.33: the mean over twelve years, not 2007.
• The file has twelve years per country. The prompt did not say so, and the model had not seen the file.

Run it, then ask what it averaged over. Seventy-four is a real mean of real numbers, of the wrong rows.

Three failure modes and reasons behind them

Failure	Comes from	Gapminder version
Confident but wrong	Fact 1: plausible before correct	“Oceania’s 2007 life expectancy was 80.7 years”, from memory
Made up references	Fact 2: generates, does not look up	three papers with DOIs, one of which resolves to nothing
Plausible-but-wrong recipe	Facts 1 and 2	a mean over all twelve years when you meant 2007

The three rows: the references you just checked, the recipe you just ran, and the number from memory, which the live demo shows later. Only the middle one announces itself, and only if you check the DOI. The other two run clean and read fine.

One check per conversation

• Every conversation: pick one claim, check it, before you use anything else.
• A reference: doi.org, then Scholar.
• A number: the file, by hand or by a script you ran.
• A line of code: run it, read what it printed.
• A sentence about your code: the line it describes.

Check one claim every time, not only when a reply looks wrong. If the one you check fails, the rest of the reply is unchecked too.

Context: what the model has in front of it

• In the window: your messages, its replies, pasted code, attached files, the level you named.
• Not in the window: your screen, your folder, the file you did not attach, yesterday’s chat.
• The wrong-years recipe was a context failure. str(d) in the message fixes it.
• What you paste in decides what you get back.

The model answers the question it can see. Put the file in front of it, or the shape of the file.

Three prompts for one question

Prompt	What comes back
Basic: the question alone	five numbers, from memory
With pasted context: str(d), head(d, 3), “base R only”	one line of code that fits your columns
Asking for a script at code/..., saying what it reads and what it prints	a file you can run and keep

The third one is the only one you can re-run tomorrow.

The same question produced three objects. Only the third is something you can check tomorrow the way you checked it today. The three prompts are on the page in full.

Attaching the CSV

1. +: the attach menu
2. Add files or photos: the file dialog
3. File chip above the box: it is in the context
4. Public data only: never licensed or borrowed work

Once the chip is there, the model can open the file. Before that, it had only the column names you typed. The same menu holds the Web search toggle: that is where it goes off for the references demo.

The four parts of a prompt that works

1. Say what you want. “The population-weighted mean life expectancy for each continent in 2007.”
2. Say what it will probably get wrong. It has not seen your file. “The file has twelve years per country: use only 2007. Weight by population, not a simple mean.”
3. Ask for a script, not the answer. Name the file and say what it reads, writes and prints.
4. Say what not to do. “Do not compute the numbers here. Do not invent columns. If the file is not as described, stop.”

Every prompt today has these four parts. Part 2 is the one nobody writes, and it is the one that would have prevented the script that averaged all twelve years. The full prompt is on the next slide.

Asking for the script: the prompt

Prompt to paste into Claude, with gapminder.csv attached

The attached file is gapminder.csv: one row per country and year; columns
country, continent, year, lifeExp, pop, gdpPercap; 1704 rows; 142
countries; years 1952 to 2007 every five years. In my RStudio project it
sits at data/gapminder.csv.

Goal: the population-weighted mean of lifeExp for each continent in 2007.

Write an R script I will save as code/2_lifeexp_weighted_2007.R. Base R
only, no packages. Read the file with read.csv("data/gapminder.csv"). Keep
the rows for 2007 first; the file has twelve years per country. For each
continent compute sum(lifeExp * pop) / sum(pop); do not take the simple
mean across countries. Write output/lifeexp_weighted_2007.csv with the
columns continent and weighted_lifeExp, and end with cat() lines that
print the five values rounded to two decimals.

Do not compute the numbers here and do not paste a table; I will run the
script myself. Do not invent columns. If the file does not match what I
described, stop and say so.

Read the last paragraph. That is the sentence that turns an answer into a script. Without it, a tool that can see the file will hand you the table.

Why the script is the result

	The answer, in a chat	The script, in code/
Re-run tomorrow, elsewhere, by someone else	no	yes
Read line by line when a number looks wrong	nothing to read	yes
Fits in a commit	no	yes
The numbers come from your file	not necessarily	always

Ask for the script, not the answer. The research artifact is always code.

The table has four rows, and the last one is the quiet one: a script cannot make a number up. It can only compute it from the file, rightly or wrongly, and you can see which.

Exercise 2

• Exercise
• Solution

# Exercise 2 (9 minutes). claude.ai, a new chat; RStudio open on
# gapminder-practice.
#
# 1. Click + at the left of the message box, choose Add files or
#    photos, pick gapminder-practice/data/gapminder.csv. Wait for the
#    file chip.
#
# 2. Paste the prompt from the slide "Asking for the script: the
#    prompt", unchanged. Enter.
#
# 3. Read the reply. A script, a number, or both? If it gave numbers, it
#    did not do what you asked: reply "You computed it; I asked for the
#    script. Give me only the R script." and wait.
#
# 4. Copy the R script: a code block has a copy icon at its top right;
#    a card named after the script opens a panel with a Copy button.
#    Not a Python block. RStudio: File > New File > R Script, paste,
#    File > Save As into code/ as 2_lifeexp_weighted_2007.R. Click
#    Source. Read the five values.
#
# 5. Before you trust Oceania, in the Console:
#      (81.235 * 20434176 + 80.204 * 4115771) / (20434176 + 4115771)
#    Does the script agree, to two decimals?
#
# Two answers to compare with the room: the Oceania value your script
# printed, and the line in your script that does the weighting.

A script, and Oceania prints 81.06, the same as the Console: 81.06215. The weighting line is two tapply() sums divided, or weighted.mean(lifeExp, pop), or sum(lifeExp * pop) / sum(pop) inside a function. All three give the same number.

Debrief (1 min). Hands: who got 81.06? Who got 80.72? Anyone with 80.72 got the simple mean; the prompt said not to, and the tool did it anyway: read the line, and see the patch prompt in the Quick reference. Who got a table in the chat first? Fact 1 with a file attached: computing was the likely continuation. Who got weighted.mean() versus sum()/sum()? Same number, different text; fact 3.

When it fails, say:

• The reply computed the table and gave no script: step 3’s sentence. If it still computes, start a new chat with the same attachment and prompt.
• Oceania prints 80.72: the script took the simple mean. Paste the patch prompt from the Quick reference; do not accept a rewrite.
• could not find function "weighted.mean": impossible in base R; a typo in the paste. Copy the block again.
• cannot open file 'data/gapminder.csv': the project is not open. File → Open Project.
• The file chip never appears: the browser blocked the file dialog; drag the file from Finder or Explorer onto the message box. The file is 89 KB; size is not the problem.
• “You’ve reached your usage limit”: use the Solution tab’s script; the check in step 5 does not need the chat.

Cowork: an assistant that reaches your files

1. Cowork: the assistant tier, in the desktop app
2. Reads every file in a folder you connect (Project or folder)
3. Runs code on Anthropic’s servers, not your R
4. Writes files into the folder; you approve each
5. Pro plan and above

It is the same model with one new power: it can reach your folder. Every duty in this section follows from that.

Chat and Cowork side by side

	Chat	Cowork
How context arrives	you paste it	from the folder you connect
Reads your files	no	every file in the folder
Runs code in a sandbox	Python, on an attached file	yes, on Anthropic’s servers
Runs your R script	no	no; you run it in RStudio
Edits your files	no; you paste its output	yes, directly
What you read afterwards	the script you pasted	git status and git diff
Forces “ask for the script”	yes, by accident	no; the prompt must

The last row is the one to remember. Chat could only ever hand you a script. This tool can hand you a table and never save a script. So the rule moves into the prompt. The more capable the tool, the more of the checking you own.

Before you connect a folder: git init

git init
#> Initialized empty Git repository in .../gapminder-practice/.git/
printf '.Rproj.user\n.Rhistory\n.RData\n' > .gitignore
git add .
git commit -m "Before the assistant"
#> [main (root-commit) 3f2a9c1] Before the assistant
git status
#> nothing to commit, working tree clean

• In RStudio’s Terminal tab, the project open. Before: a clean repository (or a copy of the folder).
• After: git status, then git diff, then open every new file.
• The transcript says what it claims it did. The diff says what it did.

git init is the one new command; everything else you know. The .gitignore line hides RStudio’s own state files, which change every session. Do this before you connect any folder to any tool.

Connecting the folder

1. The folder, named under the box
2. The task box: where the prompt goes
3. Approvals, next to the folder: Manual, the setting that asks. Not Auto.
4. Stop appears in the box once a run starts: find it then

Three things to check before you type: the folder name, the empty box, the approval setting on Manual. Auto would let it act without asking. The stop control only exists while a task runs.

Live demo, chat: a question with no source

Prompt (live demo, chat)

Which five countries have the highest life expectancy?

• Five countries and five numbers come back, with no source and no date.
• Nothing in the reply can be checked from the reply: no file behind it.
• The tone is the same whether the numbers are current or not.

Live, at the keyboard: claude.ai in the browser, a new chat, web search off (the + menu under the message box, untick Web search; with it on, the model can fetch the page and the point is lost). Paste, Enter, read the reply aloud. Ask the room where the numbers came from. Then the second prompt. Twelve minutes for the whole demo: about one for this slide, five for the script half, six for Cowork.

Live demo, chat: the script request

Prompt (live demo, chat)

Write an R script that reads the life expectancy table on the Wikipedia
page https://en.wikipedia.org/wiki/List_of_countries_by_life_expectancy
with the rvest package and draws a world map coloured by life expectancy
with the maps package. Save the map to output/lifeexp_map.png. I will run
the script in RStudio. Give me the script only.

• With web search off, nothing reads the page: the model writes column names from the pattern of other Wikipedia tables.
• Paste it into RStudio, run it. When it errors, paste the whole error back, run again.
• You carry every byte between the chat and RStudio. The artifact is the script.

Live, web search still off: paste the prompt, copy the script into a new R script in the gapminder-practice project, Source. Read the first error aloud, copy the red text, paste it back into the chat with “I ran it and got this error”, copy the fix, run again. Two rounds at most; if it still fails, go to the fallback slide. The point is the carrying: the chat sees the page, the folder and the error only when you paste them. Packages: rvest and maps must be installed on the demo laptop before class.

Live demo, Cowork: the same task in the folder

Prompt (live demo, Cowork)

Working in this folder, an RStudio project. Write an R script at
code/lifeexp_map.R that reads the life expectancy table on the Wikipedia
page https://en.wikipedia.org/wiki/List_of_countries_by_life_expectancy
with the rvest package and draws a world map coloured by life expectancy
with the maps package, saved to output/lifeexp_map.png. Fetch the page
yourself and read the table's columns before you write the script. Base R
plus rvest and maps, nothing else. Do not run the script; I will run it
in RStudio. Do not change any existing file. Create output/ if it is
missing. Report the one file you wrote, then stop.

• It fetches the page itself and reads the table before writing.
• code/lifeexp_map.R appears in the folder; git status shows it.
• You run it in RStudio. If it errors, tell Cowork; it reads the file and patches it.

Live: the desktop app, Cowork, gapminder-practice connected, git status clean beforehand. Paste, send, narrate what it reports as it goes: it opens the page, reads the table, writes one file. Then RStudio: open code/lifeexp_map.R, Session → Restart R, Source; the map appears in output/. If it errors, paste the error into the Cowork task box and run again. Then the Terminal tab: git status lists what appeared, the script under code/ and the PNG under output/. Cowork does not run R; that is why the prompt says so and why you run it.

Fallback: the tested script and its map

Tested 2026-09-15: figures/08-ai-chat/demo/wiki_lifeexp_map.R, on the session page. 227 countries and territories, 214 drawn; the rest grey.

If either half of the demo fails on the day, this is the script that works: the page holds it in full. Show the map, name the two packages, and move on. The lesson does not depend on the live run succeeding; a failure that you paste back is the lesson.

The disclosure block

AI disclosure, at the end of the note

## AI disclosure
- Tools: which ones, by name
- Used for: what you asked them to do
- Checked: what you verified, and how

• A heading and three lines, this shape, at the end of the note with every piece of work you hand in.
• Disclosed use is never penalised. Undisclosed use is misrepresentation.
• The third line is the one the grader reads first.

The block is a heading and three lines; copy the shape. The third line is where you show that you own the numbers.

A filled-in disclosure block

AI disclosure, filled in

## AI disclosure
- Tools: Claude Sonnet 5 at claude.ai (free plan), September 2026.
- Used for: writing code/2_lifeexp_weighted_2007.R from a prompt that gave
  the columns, the 2007 filter and the weighting; explaining
  code/1_lifeexp_2007.R line by line.
- Checked: sourced both scripts from a fresh R session; Oceania 2007 gives
  80.72 unweighted and 81.06 weighted, matching a hand calculation from the
  Australia and New Zealand rows. One sentence of the explanation described
  the tapply() mean as population-weighted; the code counts each country once.

• Checked names a number, a method, and one thing that was wrong.
• “It worked” is not a check. “The model did it” is not a defence.

The third line names a number, how you got it, and one thing the tool got wrong. That is the line the grader reads first.

What the syllabus says about AI

• Permitted by default, on every piece of work you hand in.
• Disclosure is mandatory: the block above. Disclosed use is never penalised.
• No-AI zones: in-class quizzes and exercises announced as such.
• You own every number. “The model did it” is not a defence.
• Protect data and people: no licensed data, no one else’s work, no personal information.

These five rules have been on the syllabus since August. The block on the previous slide is how you satisfy the second one.

Practice

Nine exercises on the session page, with solutions behind a click. All of them run in a chat you can throw away and in gapminder-practice, never in a graded repository.

• 1–3 Prompts: an error, three styles for one question, a plan
• 4–5 Reading a reply against the file: a sandbox number, three references
• 6–7 The disclosure block, written twice
• 8–9 A transcript is not a record; the chore on your own folder

Nine exercises are on the page. Six and seven are the block you will write for everything from now on; nine is the assistant’s chore on your own folder, with or without Cowork.

Quick reference

Ask for the script, not the answer. The research artifact is always code.

Every prompt shape, every check and the disclosure block from today, one line each, on the session page, with the things that bite.