Two reasons

Speed. Tasks that used to fill a day (reorganising a folder, drafting a README, writing a download script, styling a figure) compress to minutes. You still make the research decisions. The agent does the typing.

Calibration. Your adviser, future co-authors, and the researchers whose papers you read will all be using these tools. You need to know what they can and can’t do, and where they cut corners.

Same task, two worlds

An agent is not a smarter chatbot.

The chatbot is locked inside a text box. The agent has hands: it reads files, runs commands, writes code, closes its own error loops.

The next four slides show the same research task under both tools, side by side.

Task 1. “What packages does this project use?”

The agent opens your files and writes new ones. The chatbot cannot.

Task 2. “This script broke. Fix it.”

The agent sees its own output. The chatbot needs you to paste.

Task 3. Bulk rewrite, and Task 4. Three plot styles

When is an agent actually worth it?

Agents win on the paperwork around the research, not the research itself.

Play with it, seriously

You won’t get the felt difference from reading. Open a terminal, start a session, try things like:

• Download monthly BLS employment data for one US state and plot it.
• Merge three scripts from your last seminar paper into one.
• Draft a short literature-review summary of a paper for your thesis.
• Port a data.table pipeline to dplyr.
• Write a LaTeX beamer deck from the outline in notes.md.

A few cents of tokens (or five minutes of a Max session) buys a lot of trying.

Watch the loop

Six prompts. Empty folder. Claude Sonnet.

$ mkdir ~/demo && cd ~/demo
$ claude

▸ Write plot_iris.R: load iris, plot sepal length by species.
▸ Run Rscript plot_iris.R.
▸ Restyle it following Kieran Healy's ggplot2 best practices.
▸ Save to figures/iris.pdf and figures/iris.png at 300 DPI.
▸ /cost

Watch: diff previews, permission prompts, /cost reporting tokens used.

What just happened

• The agent read an empty folder and wrote a new file.
• It ran the script. The output returned to its own context.
• It iterated: restyled, saved, without re-stating the goal.
• You saw the cost (tokens on API, or a Max session summary).

That was Level 3. Next: the ladder.

If you tried Copilot and weren’t impressed

…you were at Level 1. Level 3 is a different tool.

An RA that lives on your computer

Not a search engine. Not a chatbot.

A competent but junior RA with a terminal open on your project.

• You give instructions.
• It works.
• You verify.

If you’d hire an RA without checking their first output, you’re hiring wrong. The agent is no different.

You’re not having a conversation

You are passing a very long document back and forth.

Each turn, the model receives:

• the entire prior conversation
• the files you added
• a repo map
• your new message

Up to 200k or 1M tokens. Sounds like a lot. Fills up faster than you’d think.

Context degradation: the single most important idea

As the document grows, performance drops. The agent forgets rules, makes sloppier edits, gives foggy summaries.

Fix it with session hygiene, not a bigger context:

• /clear when switching topics
• /compact to compress a long session and keep going
• Break big tasks into several short sessions
• Put decisions in a file the agent re-reads, not only in chat

The basic loop

1. Instruct. Tell the agent what you want.
2. Read the diff. Claude Code shows you exactly what will change.
3. Approve or cancel. Accept the diff, or hit Esc and re-prompt.
4. Iterate. Refine in the next message.

Most of the work is in step 4.

The tool

Claude Code is Anthropic’s terminal-native coding agent.

• Runs in any terminal (macOS / Linux / WSL / inside Docker).
• Reads and writes files in your project.
• Runs shell commands (asks first by default).
• Uses Claude Opus / Sonnet / Haiku; you pick per task.
• Reads a CLAUDE.md briefing file on startup (see Part 7).
• Has built-in /plan (draft first, act second), /init, /compact, /cost.

We use Claude Code for the rest of today and all of Day 2.

Two ways to pay

Either path works today. If you don’t already have Max, start with $5 in API credits.

Want other models (GPT-5, DeepSeek, Gemini)?

Claude Code uses Claude. For other model families, Aider + OpenRouter is the flexible alternative.

We don’t teach it in the main flow, but the Day 2 tutorial appendix has a full setup: one API key, ~300 models, per-key spend caps.

That setup is useful for:

• comparing models on the same task,
• cheap warm-ups on free-tier models (Qwen Coder, DeepSeek),
• the architect + editor split (reasoner plans, cheap model types).

Track A. Claude Max (flat subscription)

1. Go to claude.ai, sign in, open Settings → Plan.
2. Pick Max 5× or Max 20×. Activate.
3. Open a terminal (or enter the workshop Docker container).
4. Run:

$ claude login  # opens browser, OAuth with claude.ai
$ claude         # first session

Track B. API tokens (pay-as-you-go)

1. Go to console.anthropic.com, sign up, add \$5 credit.
2. Workspaces → Keys → Create. Name it workshop-day1, set a spend cap.
3. Copy the key (shown once). Starts with sk-ant-....
4. Export and run:

$ export ANTHROPIC_API_KEY=sk-ant-...
$ claude
▸ /cost  # watch spend per message

First run: what you’ll see

The prompt shows ▸, the working directory, and a permission indicator. First-time shell commands trigger an approval prompt. Type /help for all built-in commands.

Four prompt patterns

The warm-up: now you try

Same four patterns, a different dataset. Your hands on the keyboard.

$ mkdir ~/warmup && cd ~/warmup
$ claude

▸ Load mtcars, plot mpg vs weight coloured by cyl.
  Write as plot_mtcars.R.
▸ Run Rscript plot_mtcars.R.
▸ Restyle following Kieran Healy's ggplot2 best practices.
▸ Save as figures/mpg_vs_weight.pdf and .png at 300 DPI.
▸ /cost

Three small rounds, one cost check. That’s the job.

Plan first for anything non-trivial

Type /plan, then your prompt. Claude Code reads the relevant files, drafts a numbered step-by-step plan, and waits for your approval before touching anything.

▸ /plan
▸ Analyse this folder and plan how to turn it into an
  AER-compliant replication package.

[agent reads files, drafts plan, waits for OK]

You can approve (“looks good, proceed”), steer (“skip step 3, add a robustness check”), or reject outright.

One briefing file, many agents

Same content, different filename. cp CLAUDE.md CONVENTIONS.md literally works.

The file is a briefing, not a config.

Anatomy

# Project name

## Mission         one paragraph: what is the job?
## Principles      numbered non-negotiable rules
## Structure       expected directory tree
## Technical specs packages, output formats
## Don'ts          what must never happen
## Protocol        what to do when stuck

Meta-move: draft it with a chatbot on claude.ai, refine in CLAUDE.md.

/init bootstraps the first draft

$ cd ~/my_project
$ claude
▸ /init

Slash commands

Permission modes

Inside Docker, "skip all" is reasonable. The container is your sandbox; the host is untouched.

Model choice: pick the tool for the job

Switch mid-session: /model sonnet / /model haiku / /model opus.

On Max, models are included. On API, check /cost after every few messages.

The ones that bite (1 of 2)

• Vague where you should be precise. State file, format, constraints.
• Context degradation. /clear between topics; hand state off via files.
• Arguing with the model. Stop, hit Esc, change the prompt.
• Too many files pulled in. Only reference what you’re editing; let the repo map do the rest.

The ones that bite (2 of 2)

• Permission fatigue. Build an allow-list once; don’t click “yes” for every ls.
• Trusting without checking. Treat every output like an RA’s first draft.
• Sensitive data. If you wouldn’t put it on Dropbox, don’t put it in front of the agent.
• Assuming cloud execution. The agent runs locally; R, Python, tools must be installed.

Failure is part of the story

▸ Download homeownership rates by age. Write as download_data.py.

agent: trying FRED... no age-disaggregated series...
agent: switching to Census Bureau...
! Error: 403 Forbidden
agent: bot-blocked, adding User-Agent header...
✓ data downloaded, 1,416 rows saved

A 403 isn’t workshop failure. It’s how the tool looks in real use. The loop absorbs it.

Mini-exercise on the messy project

$ git clone https://github.com/AlexRieber/Workshops.git ~/W
$ cd ~/W/AI_Agents/messy_project
$ cp ~/W/Getting_Started_Agents/Tutorial/TUTOR.md .
$ claude --dangerously-skip-permissions
▸ Read TUTOR.md and act as my tutor.

What you leave with

• Claude Code installed and authenticated (Max or API).
• Mental model: RA plus long document plus context degrades.
• Four prompt patterns you will reuse every day.
• A CLAUDE.md of your own.
• Felt sense of cost, and an airbag.

Next: Day 2

AI Agents. Day 2:

Same messy project. Full AER-compliant replication package. Claude Code end-to-end, with hooks, custom skills, and the referee-2 pattern.

→ AI Agents workshop

Resources