AI/Claude Intro

Kerry Back
Faculty Workshop
Rice Business 2026

Eight sessions on using AI in teaching and research begin here, with the tool itself. Before there is anything useful to say about assignments, tutors, or research workflows, it helps to know what Claude actually is, what happens when you type into it, and what kinds of work it is and is not reliable at. Everything in the next hour is meant to be reproducible on your own machine — the prompts on these slides are ones you can copy and run, on data we will hand you.

Workshop Overview

AUG 103:00–4:00Intro to Claude

AUG 113:00–4:00Working with Claude

AUG 123:00–4:00Teaching Tools

AUG 133:00–4:00AI Tutors

AUG 143:00–4:00Student Projects

AUG 173:00–4:00AI for Research

AUG 193:00–4:00Personal Assistants

AUG 194:00–5:00Overflow/Extra

The workshop runs eight hours across eight meetings, August tenth through the nineteenth, each from three to four in the afternoon. Today is the introduction to Claude. Tomorrow is working with Claude in more depth, then teaching tools, AI tutors, student projects, AI for research, and personal assistants, with a final overflow hour on the nineteenth for whatever we do not finish. The sessions build on each other, but each is self-contained enough that missing one will not strand you.

Today’s Overview

1

Claude

2

Effective Prompting

3

Code and Documents

4

Verifying Things

5

Example Uses

The hour has five parts. First, what Claude is — the history, the architecture of an agent, and the four ways you can run it on your desktop. Second, effective prompting, which is less about magic phrases than about understanding that you are steering a prediction machine. Third, code and documents: how Claude produces charts, spreadsheets, and slide decks. Fourth, verification — how you check work you did not do yourself. And fifth, concrete examples you can run during the session.

Claude

Start with the tool: where these systems came from, what an agent actually is underneath the chat window, and which of the several Claude interfaces is worth your time. The vocabulary matters more than it might seem, because most confusion about what AI can and cannot do traces back to not knowing which piece is doing the work.

A Brief History

2022–2023

Online chatbots

2023–2024

Code and web tools

2025

CLI tools

2025–2026

CLI in an app

2026

Cowork-type agents

The arc runs from 2022 and 2023, when these were online chatbots and nothing more — you typed, it typed back. In 2023 and 2024 they gained tools: code execution and web search. In 2025 the serious versions moved to the command line, where the model could read and write files on your own machine. Over 2025 and 2026 that command-line capability was wrapped back into an app, and now, in 2026, we have agents like Cowork that carry out extended work on your files without you living in a terminal.

An Agent is a Chatbot with Tools

Code Execution

↕

User

↔︎

Agent

↔︎

LLM

↕

Other Tools

An agent is a chatbot with tools. You talk to the agent, and the agent talks to the language model. The model itself does nothing but produce text — it cannot open a file or run a calculation. What makes the arrangement powerful is everything hanging off the agent: code execution above, other tools below, whatever has been wired in. The model decides which tool to call, the agent actually calls it, and the result comes back. That separation is the single most useful thing to understand about all of this.

Agent in More Detail

The loop has five steps. You type a prompt. The agent sends the model the system prompt, the tool definitions, and the whole conversation history. The model returns either text or a request to call a tool. If it is a tool call, the agent executes it — running SQL, listing tables, running Python — and sends the result back, looping to step two. Only when the model returns a final answer does anything reach you. The messages array in the middle grows every turn and carries every tool call and result, which is why long sessions get expensive.

Anthropic’s System Prompt

Link to Opus 4.8 system prompt

Every conversation begins with a system prompt you never see, and Anthropic’s is enormous — this one, leaked for Opus 4.8, runs to many pages. It covers tone, refusals, formatting, how to use tools, when to search. Two things are worth taking from it. The behavior you experience is not raw model behavior; it is heavily shaped by instructions. And the same lever is available to you: project instructions are your own system prompt, and they persist across every conversation in that project.

Two Halves of Claude Desktop

Home or Code?

The two halves of the app, chosen at the top of the left sidebar (the square icon toggles the sidebar)

The desktop app splits in two at the top of the left sidebar: Home and Code. The square icon toggles the sidebar if you cannot find it. Home is the conversational side, the descendant of the web chat. Code is the descendant of the command-line tool, built for working directly in a folder of files. Nearly everyone in this workshop wants the Home side, but knowing the split exists explains why the app can look completely different in two people’s screenshots.

Four Modes of Claude Desktop

Within Home, Chat or Cowork?

Toggle in the prompt box

Within Code, Local or Cloud?

Selector at the bottom of the window

Each half splits again, which is where the four modes come from. Inside Home, a toggle in the prompt box chooses Chat or Cowork. Chat is the familiar back-and-forth; Cowork gives the model a working folder and lets it carry out multi-step tasks. Inside Code, a selector at the bottom of the window chooses Local or Cloud — whether the work happens on your machine or on Anthropic’s, against a GitHub repository. Four modes, two toggles, and the toggles sit in different places, which is the genuinely confusing part.

What to Use?

• You can chat in any mode
• You can execute code in any mode

Cowork > Chat on many dimensions. Requires paid account.

Code Local is best for most people, but Claude Desktop is not the best venue

Use Cowork for now

(more later)

Code Cloud is GitHub integration, probably overkill

You can chat in any mode and execute code in any mode, so the choice is less consequential than it looks. Cowork beats plain Chat on most dimensions, though it requires a paid account. Code Local is what most people would eventually want, but Claude Desktop is not the best venue for it. Code Cloud is GitHub integration and is almost certainly overkill here. For this workshop, use Cowork — we will come back to the alternatives later.

Configuration

• Create New Project + Use a Folder Give Claude access to your local files. Store project-specific instructions.
• Auto Automatically approve. Misleading name. Claude decides: safe -> don’t ask permission, possibly risky -> ask permission
• Model I recommend Sonnet 5. Capable for anything you probably want to do. Faster and cheaper (easier on token quota).

Three settings are worth changing before you start. Create a new project and point it at a folder — that is what gives Claude access to your local files, and it is also where project-specific instructions live. Set permissions to Auto, which is a misleading name: it does not mean anything goes. Claude judges each action, skipping the prompt for safe ones and still asking about anything possibly risky. And for the model, Sonnet 5 is my recommendation — capable enough for anything in this workshop, and faster and cheaper on your token quota.

Do Not Train

Consumer plans — Free, Pro, Max (what we are on)

• Settings > Privacy > Privacy Settings, then turn off Help improve Claude
• Direct link: claude.ai/settings/data-privacy-controls
• The default on a personal account is on
• Off keeps your data 30 days; on keeps it five years

Commercial plans — Claude for Work, Education, API

• Your data is never used for training, and there is no setting to find
• Includes the API, and the API through Amazon Bedrock and Google Vertex
• If Rice moves us onto one of these, the setting disappears from your account — nothing to do

It is one account setting, not an app setting: it covers Chat, Cowork, the command line, and the Academic Studio extension at once. And it is not in the Anthropic developer console — that is a separate product for API keys.

Whether your conversations train the model depends on your plan. On consumer plans — Free, Pro, and the Max plan we are on — the default for a personal account is on, and you turn it off under Settings, Privacy, Privacy Settings, by switching off Help improve Claude. Turning it off also shortens retention from five years to thirty days. On commercial plans — Claude for Work, Education, or the API — your data is never used for training and there is no setting to find. It is an account setting, not an app setting, so it covers Chat, Cowork, the command line, and Academic Studio all at once.

Effective Prompting

Prompting has accumulated more folklore than almost any part of this, and most of it is obsolete. The parts that still matter follow from a single fact: the thing on the other end predicts text. It does not reason about your goals, it does not remember what it told you last week, and it does not push back unless you ask it to. Four consequences are worth building into how you work.

Plan Mode

Claude Desktop has an explicit Plan mode. Or add “plan how to do this before you start.”

Why It Works: Knowledge

• Planning pulls relevant knowledge into the context window
• The model answers in light of what it just retrieved, not base rates

Why It Works: Scale

• Decompose the work into subtasks
• Verify each one before the next
• Failures stay small and local

Asking for a plan before any work happens is the highest-return habit available. Claude Desktop has an explicit Plan mode, and failing that, just add: plan how to do this before you start. It works for two reasons. Planning pulls relevant knowledge into the context window, so the model answers in light of what it just retrieved rather than falling back on base rates. And it decomposes the work into subtasks you can verify one at a time, which keeps failures small and local instead of discovering at the end that everything is wrong.

AI is a Prediction Machine, not a Rational Person

Suppose Claude has told you in the past that Method A beats Method B for some task. You ask it to do the task.

Do not assume it will use what it knows. If “A beats B” is not in the context window, and B appeared more often in its training data, it will probably use B.

This is the value of “plan before you act.” Planning surfaces “A beats B,” leading Claude to select A for the task.

To see why planning matters, suppose Claude told you last month that Method A beats Method B for some task, and today you ask it to do the task. Do not assume it will use what it knows. If the sentence A beats B is not in the current context window, and B appeared more often in the training data, it will probably reach for B. Knowledge in the weights is not knowledge in use. Planning is what surfaces A beats B into the conversation, and once it is there, the prediction machine predicts A.

Beware of Tunnel Vision

Prediction also means momentum. Once Claude has started down a path, continuing it is the likeliest next step.

What you will see

• It hits a roadblock and tries to get around it
• Then another way around, and another — exhaustively, tenaciously
• What it rarely does is return to the start and ask whether a different path was the better one all along

What helps

• Periodically ask: are there other approaches that might work better for reaching the end goal?
• Restate the goal, not just the obstacle — that gives it permission to abandon the path instead of defending it

Prediction also means momentum. Once Claude has started down a path, continuing that path is the likeliest next step, and you will watch it hit a roadblock, find a way around, hit another, and find another way around — exhaustively and tenaciously. What it rarely does is return to the beginning and ask whether a different path was better all along. Two things help. Periodically ask whether other approaches might reach the goal better. And restate the goal rather than the obstacle, which gives it permission to abandon the path instead of defending it.

Steelmanning

Don’t ask AI whether your idea is good. Ask it to make the strongest possible case that your idea is wrong.

Sycophancy: training on human feedback teaches that agreement gets high ratings. Ask “is my plan sound?” and Claude finds reasons it is.

The fix: “What is the strongest argument against this acquisition?”

One step further: have it play a skeptical board member, a regulator, a competitor.

Never ask AI whether your idea is good. Training on human feedback teaches that agreement earns high ratings, so asking is my plan sound reliably produces reasons that it is. That is sycophancy, and it is a property of the training rather than a bug you can prompt away. The fix is to invert the question: ask for the strongest possible case that you are wrong. What is the strongest argument against this acquisition? One step further, have it play a specific skeptic — a board member, a regulator, a competitor — because the role pulls in the objections that role would actually raise.

Numbers Need Code

Never trust AI arithmetic. Have it write and run code.

The Problem

• “47.3%” is as plausible as “52.1%” to a next-token predictor
• Mental math, rankings, comparisons, aggregations — all unreliable
• Wrong numbers stated with complete confidence

The Fix

• Ask for Python, and have it run
• Arithmetic becomes computation, not prediction
• Code execution is built into every chatbot and Claude Code

Never trust AI arithmetic. To a next-token predictor, forty-seven point three percent is exactly as plausible as fifty-two point one. Mental math, rankings, comparisons, and aggregations are all unreliable, and the wrong number arrives with complete confidence. The fix is mechanical: ask for Python and have it actually run. That converts arithmetic from prediction into computation, and it is not an exotic capability — code execution is built into every chatbot and into Claude Code. If a number matters, it should have come out of code you can look at.

What Not to Do

2022–2023 conventions are now useless or counterproductive.

Skip These

• “Think step by step” — reasoning models already do, in hidden tokens
• “Take a deep breath” — measurably useless now
• “CRITICAL! NEVER EVER…” — overtriggers, and gets worse results

Use With Care

• “You are an expert data analyst …”
• Persona stacking can improve tone and structure
• Direct task framing usually wins

The prompting conventions of 2022 and 2023 are now useless or actively harmful. Skip think step by step — reasoning models already do that, in hidden tokens. Skip take a deep breath, which was measurably useless. And skip shouting: all-caps CRITICAL, NEVER EVER overtriggers and produces worse results, not better ones. Personas deserve more care than outright dismissal. You are an expert data analyst can genuinely improve tone and structure, but stacking personas rarely helps, and direct task framing usually wins.

Code and Documents

Everything the model does beyond producing text, it does by writing code. That one sentence explains the charts, the spreadsheets, and the slide decks, and it also explains the limits on all three. Three examples make the pattern concrete: pulling data from a public source and plotting it, generating a PowerPoint deck from a data request, and building an Excel workbook with live formulas in it.

Example Prompt

Download three FRED (Federal Reserve Economic Data) series as CSV: mortgage rate (MORTGAGE30US), home price (MSPUS), household income (MEHOINUSA672N), 1990 through most recent.

1. MORTGAGE30US is weekly — resample to quarterly by averaging. MSPUS is already quarterly. MEHOINUSA672N is annual — interpolate linearly between annual observations to produce quarterly values.

2. Assume a 20% down payment and a 30-year loan. Compute the monthly mortgage payment on a median-priced home and express it as a percentage of monthly median household income.

3. Plot the affordability ratio as a line chart. Annotate three points: the 2006 bubble peak, the 2012 trough (most affordable in decades, as low rates met depressed prices), and the 2023 spike.

The prompt asks for three series from FRED — the thirty-year mortgage rate, the median home price, and real median household income — from 1990 forward. Notice how much of it is specification rather than request. The mortgage rate is weekly and must be averaged to quarterly, the price series is already quarterly, and income is annual and must be interpolated. Then the finance: twenty percent down, a thirty-year loan, and the payment expressed as a percentage of monthly income. Then the chart, with three specific points annotated. That detail is not pedantry — it removes the decisions you did not want it making.

Result

The result is a single line: the monthly mortgage payment on a median-priced home as a percentage of median household income, from 1990 through 2024. The 2006 bubble peak reaches about twenty-one percent. The 2012 trough, at fifteen point four, was the most affordable in decades, because low rates met depressed prices at the same moment. And the 2023 spike hits thirty-three point six percent — half again above the housing bubble peak. The whole thing, from data download through annotation, came out of the prompt on the previous slide.

Reading, Editing, and Writing Documents

Claude natively reads text and images, and natively writes text. Everything beyond text is handled by code.

• Document reading is doc -> text, then read
• Document creation is text (code) -> doc
• Office document editing is ‘read and write XML (Extensible Markup Language)’

Claude natively reads text and images, and natively writes text. Everything past that is handled by code, and the pattern is worth memorizing. Reading a document means converting the document to text and then reading the text. Creating a document means writing code that emits the document. And editing an Office document — Word, Excel, PowerPoint — means reading and writing the XML inside it, because those formats are zipped XML underneath. Nothing magic is happening. It is a competent programmer working with file formats.

Example

Get Tesla’s EPS from SEC EDGAR by quarter for the past 5 years. Plot. Create a PowerPoint deck with the plot plus discussion.

The result

tesla.pptx

Three sentences: get Tesla’s quarterly earnings per share from SEC EDGAR for the past five years, plot it, and create a PowerPoint deck with the plot plus discussion. The resulting deck is linked here and you can download it — it is a real PowerPoint file with editable text boxes, not a picture of one. What is worth noticing is the chain: a public data source, a fetch, a computation, a chart, and a document, carried out end to end from a request that took ten seconds to type.

Creating Excel Workbooks

Claude uses Python to create Excel workbooks, inserting numbers (inputs) and formulas cell-by-cell

Example Prompt

Build an Excel workbook containing a mortgage amortization table. Include a chart of the amount going to interest and the amount going to principal each month.

Result

amortization.xlsx

Excel works the same way, with one important difference. Claude uses Python to build the workbook, writing it cell by cell — inputs as numbers, and formulas as actual formulas. Ask for a mortgage amortization table with a chart of the interest and principal portions each month, and what comes back is a live workbook: change the rate and the table recalculates, because the formulas are really in the cells. That matters for teaching, where a static table of numbers and a working model are entirely different objects.

Claude Plugin for Excel

A chat panel inside Excel itself. Add it from Home → Add-ins. You will be prompted to connect to your Anthropic account (paid account).

Example

There is also a chat panel inside Excel itself, added from Home, then Add-ins. It will prompt you to connect to your Anthropic account, and it requires a paid one. The advantage over the desktop app is that it sees the workbook you already have open, so you can ask about the sheet in front of you rather than describing it or uploading a copy. The disadvantage is that it is bounded by Excel — for anything involving outside data or other file formats, the desktop app remains the better place to work.

Verifying Things

The hardest part of working with AI is not getting it to produce something. It is deciding whether what it produced is right, in a situation where you did not do the work and cannot easily retrace it. Five habits cover most of the risk: verifying factual claims, thinking clearly about how code goes wrong, three specific questions worth asking every time, using a second instance as an adversary, and keeping code that already works.

Verify Claims

The Problem

• Facts, regulations, dates, citations — stated the same way whether real or invented
• The more obscure the fact, the likelier it is fabricated

The Fix

• Have it search before answering
• Ask for sources. Then check them.

Facts, regulations, dates, and citations are stated exactly the same way whether they are real or invented — there is no tell in the prose, because confidence is not correlated with accuracy. And the risk runs in the wrong direction: the more obscure the fact, the thinner the training data, and the likelier it is fabricated. The fix has two parts. Have it search before answering, which grounds the response in retrieved text rather than recall. Then ask for sources, and actually check them, because sources can be invented too.

Verify Code

Consider a human assistant. Ask where they could have gone wrong.

• They may not have understood what you wanted.
• To perform the task, they may have had to make decisions that were different from the decisions you would have made.
• Their Excel, code, or whatever may have had subtle bugs so it did not do what they expected.

Claude can go wrong in exactly the same ways. How do you check them?

A useful way to think about checking work is to imagine a human assistant and ask where they could have gone wrong. They may not have understood what you wanted. To finish the task they may have had to make decisions, and made them differently than you would have. And their spreadsheet or their code may have had subtle bugs, so it did not even do what they thought it did. Claude goes wrong in exactly those three ways — no more exotic and no less common. The question is how you check for each of them.

Three Checks

Take advantage of the fact that AI is perfectly patient. You can probe more deeply than you would with a human assistant, and it will not be offended.

Check its understanding

Explain to me what you did and how you did it.

Check its decisions

Report all ways in which my instructions were ambiguous and you made decisions we have not discussed.

Check its code

Show me a sample case and work through the case as if by hand so I can verify your number.

Take advantage of the fact that AI is perfectly patient. You can probe far more deeply than you would with a human assistant, and it will not be offended. Check its understanding: explain to me what you did and how you did it. Check its decisions: report all the ways my instructions were ambiguous and you made choices we have not discussed — that one surfaces an astonishing amount. And check its code: show me a sample case and work through it as if by hand, so I can verify the number myself.

Generator-Critic

Spawn a second Claude to attack the first one’s output, not validate it. Subagents work well — several of them.

The Pattern

• Generator produces the work
• Critic gets: “Find every factual error, logical gap, and unsupported assumption. Do not summarize — find flaws.”

Why a Separate Instance?

• A model is anchored to its own output and defends it
• A fresh instance with an adversarial mandate is not

A step beyond self-checking is to spawn a second Claude whose job is to attack the first one’s output rather than validate it. Subagents handle this well, and several of them work better than one. The pattern is two roles. The generator produces the work. The critic is told to find every factual error, logical gap, and unsupported assumption — explicitly not to summarize, but to find flaws. The separate instance is the point: a model is anchored to its own output and will defend it, while a fresh instance with an adversarial mandate has nothing to defend.

Re-Use Tested Code

Once code runs correctly, save it. Re-use it rather than rewrite it.

The Problem with Rewriting

• Different choices each time
• Scripts that should agree may not
• Old bugs reappear

Once code runs correctly, save it and re-use it rather than asking for it again. Regenerating looks free, but it is not. You get different choices each time — a different way of handling missing values, a different definition of the same variable — so two scripts that ought to agree quietly do not. And bugs you already found and fixed reappear in the new version, because nothing about the fix was ever written down. A folder of tested scripts is one of the more valuable things you will accumulate.

Andrej Karpathy, OpenAI co-founder, former Tesla AI chief, now at Anthropic

October 2025

“They just don’t work. They don’t have enough intelligence, they’re not multimodal enough, they can’t do computer use and all this stuff. They don’t have continual learning. You can’t just tell them something and they’ll remember it.”

“I feel like the industry is making too big of a jump and is trying to pretend like this is amazing, and it’s not. It’s slop.”

December 2025

“I really am mostly programming in English now, a bit sheepishly telling the LLM what code to write… in words. Biggest change to my basic coding workflow in ~2 decades.”

February 2026

“It is hard to communicate how much programming has changed due to AI in the last 2 months: not gradually and over time in the ‘progress as usual’ way, but specifically this last December. Coding agents basically didn’t work before December.”

“I don’t think I’ve typed like a line of code probably since December.”

How fast this is moving is easy to underrate, and Andrej Karpathy is a useful witness — OpenAI co-founder, formerly Tesla’s AI chief, now at Anthropic. In October 2025 he said coding agents simply did not work: not intelligent enough, no continual learning, and the industry pretending otherwise was, in his word, slop. By December he was programming mostly in English, calling it the biggest change to his workflow in two decades. By February 2026: coding agents basically did not work before December, and he had not typed a line of code since. Three months, from dismissal to not writing code at all.

Examples of Claude Use

The rest of the hour is hands-on, on data small enough to inspect and realistic enough to be annoying — five related tables that have to be joined before any question can be answered. The exercise is a business question end to end: merge, filter, aggregate, chart, and produce a deck. After that, two examples about where spreadsheets still belong and where they do not.

Some Local Data

Extract the following from session1.zip into your project folder or just put session1.zip there and tell Claude to extract.

File	Rows	Key Columns
northwind_customers.xlsx	93	CustomerID, CompanyName, Country
northwind_orders.xlsx	500	OrderID, CustomerID, OrderDate
northwind_orderdetails.xlsx	18,976	OrderID, ProductID, UnitPrice, Quantity
northwind_products.xlsx	77	ProductID, ProductName, CategoryID
northwind_categories.xlsx	8	CategoryID, CategoryName

The data is the Northwind sample database, split into five Excel files. Extract them from the session one zip file into your project folder, or just put the zip there and tell Claude to extract it — it will. Customers has ninety-three rows with a country column. Orders has five hundred rows keyed to customers. Order details is the big one at nearly nineteen thousand rows, carrying unit price and quantity. Products and categories are small lookup tables. Revenue lives in order details, country lives in customers, and category names live in categories, so any interesting question requires all three.

Merge, Filter, Aggregate, Chart, Analyze, Create

Copy this prompt into Claude:

I have five Northwind files in my project folder: customers, orders, order details, products, and categories. Which product categories generated the most revenue from customers in Germany and France? Show only categories above $10,000, sort highest to lowest, create a bar chart, and put it in a PowerPoint deck. Add some discussion.

Copy this prompt in as written. It asks which product categories generated the most revenue from customers in Germany and France, showing only categories above ten thousand dollars, sorted highest to lowest, as a bar chart, in a PowerPoint deck with discussion. Every verb in the title is in there: it has to merge five files, filter to two countries, aggregate revenue by category, chart it, and build a document. What would be half an hour of spreadsheet work is one paragraph — and the useful exercise afterward is checking whether the number is right.

Role of Excel

The first spreadsheet program, VisiCalc, was created by a Harvard MBA alum who was inspiried by watching his prof do pro-formas, valuation, and sensitivity analysis on a blackboard with chalk and eraser

Spreadsheets later became the go-to in business for most things numeric

Spreadsheets remain valuable for tabular add-subtract models

Everything else should be done by code written by AI

VisiCalc, the first spreadsheet, was written by a Harvard MBA alum who watched his professor redo pro formas, valuations, and sensitivity analysis on a blackboard with chalk and an eraser, and thought the recalculation ought to be automatic. Spreadsheets went on to become the default tool in business for anything numeric, a far broader role than that origin implies. They remain genuinely good at what they were built for: tabular models that add and subtract. Everything else should be done by code — and now the code can be written by AI.

Example

• Extract regression.html from session1.zip and double-click
• It will open in your browser. Upload regression-example.xlsx into the browser.

Lessons

• This was built by Claude from simple prompts.
• It is even easier to just run one regression analysis.
  
• Students learn as much about regression from prompting Claude as from running it in Excel.
  
• Apps like this can be student assignments (more later).

Extract the regression app from the session one zip file and double-click it. It opens in your browser as a self-contained page, and you upload the example workbook into it. Several lessons here. Claude built the whole thing from simple prompts. It is actually easier to just ask for one regression than to build an app for regressions, so the app itself is not the point. Students learn as much about regression from prompting Claude as from running it in Excel. And apps like this can themselves be student assignments, which we come back to in a later session.

Takeaways

There is no secret to prompting. Just chat (a lot). Treat AI as an infinitely patient colleague with a poor memory. Code execution gives AI enormous power.

Three things to carry out of the hour. There is no secret to prompting — the phrases people trade around do not matter much, and the way to get good at it is to chat, a lot, and pay attention to what works. Treat AI as an infinitely patient colleague with a poor memory: you can ask anything as many times as you like, and you have to supply the context every time, because it remembers nothing. And code execution is where the power comes from. A model that can run code is a different tool from one that cannot.

Homework

Watch the three-minute video academic_studio.mp4

One thing before tomorrow: watch the three-minute Academic Studio video linked here. It introduces the environment that several of the later sessions build on, and three minutes now saves explaining it twice. Tomorrow’s session goes deeper on working with Claude — projects, instructions, and the habits that keep longer pieces of work holding together.