Teacher notes

AI in the terminal · Department of Strategy and Entrepreneurship · 22 and 23 October 2026

The shape of the two days

Two goals, as always: they leave knowing these tools do far more than they thought, and believing they can do it themselves on Monday. Everything else is in service of that.

  • Thursday 12–16: everyone running, safely. All of it is mandatory, in order. Setup, save points, what it can touch, something tedious. By 16:00 every laptop runs an agent with git, and everyone has watched an undo. Not everyone comes both days, and Siri’s line is that day one is what matters: so Thursday must stand on its own. It starts with the install, and ends with 50 minutes on their own tedious thing.
  • Friday 09–13: research, all of it mandatory up to the words. Their field (as I imagine it), the profile, a paper taken apart, interviews coded, references checked. Then Words you’ve heard, own work, and the short, optional teaching block at the end. Birgitte asked for it to be short: several of them have taken BI’s AI-for-teaching course.
  • Qualitative and quantitative, both. Birgitte asked for it explicitly, and the invitation promises “interviews, documents and literature to data, with examples from both traditions”. Every research block has a qualitative route: interview papers in paper, the interviews block for everyone, quotes checked word for word. And the invitation says qualitative people are “especially welcome to share what works”: ask them, out loud.
  • No research menu this time. In Finance, “you choose” fell flat: nobody had an opinion, because you can’t choose between workflows you haven’t seen (debrief, note 6). So I decide the research blocks, and the room chooses only among words they’ve heard, which needs nothing but curiosity. Referee panel, Leave a trail and Notes and structure are in the handout for any time.

Where things are. One deck per module in decks/. Open decks/menu.html first: every card opens a module’s deck, and Menu in each deck’s footer comes back. Inside a deck, press M for the slide list and Esc for the overview. handout.html has every prompt with a copy button, section-numbered to match the slides.

Deck What Minutes
menu Title, the menu, “one folder”, the course files 5
setup Install, log in, git (required), which model and limits, five keys, first contact. First thing on Thursday 45
power Capability talk: two kinds of contest (algorithm vs heuristic, for the question Finance asked), programming, maths benchmarks, a released model on open problems, Navier–Stokes, the 6 October results, “the biggest day in history?”, Duminil-Copin; ends on a teaching slide (an animation written as code) ~10
how What an LLM is (training: pre-training, feedback, RL; use: thinking), prompt engineering (RIP), what an agent is, usage limits 6
git Git: save points. What git is, where it comes from (timeline, two charts), for the agent, vs OneDrive, .gitignore, the cloud, five words, ask about the rest, GitHub and Pages. Four exercises 30–35
access What it can touch: how far each tool reaches, what leaves the laptop, the dial, auto mode, what we tried, why lots of access, three ways to say no, training switches, personal data. Three exercises 20–25
cleanup Do something tedious: the WISEflow export, with a git save point and an undo 25
knows Your field as I imagine it, tell me what I got wrong, context, who is asking, the Berger demo, does it matter in your field, how you work, your profile 25
paper Take a paper apart 45
interviews Interviews: a codebook, coded transcripts, every quote checked 35
refs References: search (exercise), papers in the folder, DOI check, claim check. Friday: the 30-minute version 30 (40–60 for all)
words Words you’ve heard: nine tiles, the room picks three or four. Skills, subagents, plan mode, context and /compact, worktrees, agents in the cloud; connectors, the project file and GitHub open their own decks 30
review Referee panel, any time ~40
trail Organise a folder, the rerun test, what the rerun found ~50
notes Four questions, structure, notes, project file, skills 20–30
own Open lab and close 30+
teaching Optional, end of Friday: course material from plain text 20–25
agents If asked: the project file, one AGENTS.md for both tools, asking for changes 10
github If asked: git vs GitHub, setup, co-authors, public or private 10
mcp If asked: connectors (MCP), switching one on, one example each for email, calendar, Drive 5
more Backup: security, benchmarks, Eco, Concord, prompting; the long capability talk as needed

Before Thursday

  1. Room. Not booked as of 5 October (A2 nearly full; Line said C2 had space). Confirm with Line, and put the room on the course page. Check that power reaches every seat; bring extension cords.
  2. Brief Ludvik and Leonardo (the page below). Send it Wednesday evening. Before Thursday they each have Claude Code or Codex running on their own laptop, have done the git and access exercises once (handout sections 2 and 3), and Ludvik has a GitHub account with gh logged in, for the pull-request demo.
  3. Bring: sticky notes in two colours (yellow and pink, two per person), a flipchart or whiteboard and pens for the parking lot, extension cords, and the course zip on a USB stick.
  4. Course files. course-files.zip (the handout and the practice folders, unpacked) is what people download from vibing.jonasmoss.com → Strategy and Entrepreneurship (on the menu deck’s “Get the course files” slide). After any change to the handout or a prop: re-render, then python3 make-course-files.py, commit, push.
  5. Test on a BI-managed Windows laptop, on campus wifi: install, log in, one prompt, one PDF read, and git without admin rights (the portable route). Also check that /usage (Claude Code) and /status (Codex) still show the plan limits in this week’s versions. Dagfinn’s Codex install stalled in August until he picked the restricted (unelevated) mode.
    • Tested 14 October on a BI PC: the Claude Code install needed no admin rights, but asked for .local\bin to be added to PATH by hand. Fixed: the Claude install is now two lines, the second adds it to the user PATH.
    • Not tested on a BI PC: right-click → Open in Terminal, explorer ., and whether Documents sits in OneDrive. If it does, keep practice folders in the home folder (where mkdir practice puts them): git and OneDrive syncing don’t mix well.
  6. Demo papers.
    • “Take a paper apart”: your own pick, or one the room names on Friday morning.
    • Referee panel: Denrell and Liu (2012), “Top performers are not the most impressive when extreme performance indicates unreliability”, PNAS 109(24), doi:10.1073/pnas.1116048109. Six pages, on the luck theme from the field slide. Getting it live: PNAS refuses scripted downloads (403, checked 21 October), and PubMed Central’s PDF sits behind a browser check, but its article page has the full text: “Save the full text of https://pmc.ncbi.nlm.nih.gov/articles/PMC3386112/ into this folder.” Backup: your local copy, scratch/links/strategy-canon/pdfs/denrell-liu-2012.pdf (gitignored).
    • Luck-test card: no paper needed (see “Your own work” below).
  7. The Foldnes example. Make only the airtight claim: the paper they cite does not exist; the DOI resolves to a 2022 editorial acknowledgement. Details are in scratch/examples/references/README.md.
  8. Pre-run the backups on Claude: the Berger demo (one-line profile), plus one referee report from a fresh session.
  9. Leave a trail overlaps with the cleanup: both organise a messy folder with a git save point. If it’s picked, lean on the rerun test, not the tidying.

For Ludvik and Leonardo

Thank you for helping. In Finance, two things went wrong that you can fix: one person never got the agent running and sat idle for four hours, and the room was derailed about 15 times by questions that mattered to one laptop. Your jobs are built around those two.

Ludvik: nobody is left without a working agent.

  • Thursday 11:00–12:00: install drop-in in the room. Anyone can come early.
  • During setup (12:05–12:50), first thing: roam, Windows first. Common trouble: the “x86” PowerShell; not closing and reopening PowerShell after the install; Command Prompt instead of PowerShell; Codex’s admin or sandbox prompt (choose unelevated); git needing admin rights (ask the agent to install portable Git into the user folder).
  • At 12:45, the laptop check: walk every row. Every laptop shows an agent that answers, and git --version that answers. Write down who isn’t there yet.
  • Friday 08:30–09:00: second drop-in, for Thursday’s stragglers and anyone who only comes on Friday. Then take Friday-only people through handout sections 1–3 at the side of the room, while the rest work.

Leonardo: the room stays on track.

  • One-laptop questions go to you, not the front. “Why does mine say X?” gets answered at the laptop. If it’s interesting, tell Jonas at the next break.
  • The parking lot: a flipchart. Any question that would take the room off course goes on it, with the asker’s name. Jonas answers two or three before each break, and the rest at the end of Friday. Write down the field examples people give on Friday morning, too: they get used in the paper block.
  • Watch the fast ones. Done early? Point them at the “Done early?” task on the exercise slide, then the “Any time” column of the menu. Fast people with nothing to do are where derailments come from.

Both of you:

  • Sticky notes: everyone gets a yellow and a pink one. Yellow on the lid: done, or fine. Pink: stuck. A pink note gets a visit within two minutes, from whoever is free.
  • Fifteen minutes stuck means a fallback, never more waiting:
    1. pair with a neighbour and work on their laptop for this exercise;
    2. or use claude.ai or chatgpt.com in the browser for now (the profile and paper exercises work there, minus the files);
    3. and keep fixing the install during the next talk, not the next exercise.
  • Let them type their own prompts. Typing install commands for them is fine.
  • Nobody is idle for long. Every exercise, sweep once for anyone not typing and ask what they’re trying.
  • The script for Thursday is the handout, sections 1–4. Friday is sections 5–9.

Derailments

About 15 in Finance, some substantial. The rule: the room’s time is for the room.

  • One-laptop questions go to a TA at the laptop.
  • Good questions at the wrong time go on the parking lot, answered before the next break.
  • Privacy and access have their own deck now (access), straight after git. Most of Finance’s worried questions are answered there; point back to it.
  • The big debates (“is this cheating?”, “will it replace us?”) go on the parking lot, for the end of Friday.
  • Level differences: never wait for the slowest; never let the fastest set the pace. Every exercise has a “Done early?” task, and the “Any time” column is the overflow.
  • Quick answers are ready: the two FAQ slides in git, the FAQ slide in access, and more for capability questions.

Run sheet: Thursday 12:00–16:00

Time Block Minutes Notes
11:00 Install drop-in 60 Ludvik and Leonardo, in the room.
12:00 Welcome, menu, “one folder” 5 Show the menu: this is the whole range. Hand out the sticky notes; say what they’re for.
12:05 Get it running 45 setup, first thing: install, log in, git for everyone, five keys, first contact. 12:45: Ludvik’s laptop check.
12:50 Capability talk ~10 power. Stragglers keep installing with Ludvik while you talk: the talk is their buffer. Ends on the animated teaching slide.
13:00 How it works 5 how. Don’t elaborate.
13:05 Git: save points 35 git. Four exercises, interspersed.
13:40 Break 10 Stragglers with Ludvik. Two parking-lot answers first.
13:50 What it can touch 25 access. Three exercises.
14:15 Do something tedious 25 cleanup. Names only; ends on “You decide what it reads”.
14:40 Break 10 Parking lot.
14:50 Your own tedious thing 50 The last slide of cleanup, handout section 4. A copy of a real folder, commit first, then let it try. Slower people finish the cleanup. TAs sweep.
15:40 Tomorrow 20 Three people show what they did. Parking lot. “Tomorrow: bring a paper you know well, and transcripts if you have any (pseudonymised).”

When behind: cut talk, never hands-on time. Setup will overrun; the 50 minutes at 14:50 are the buffer, not a luxury. Don’t cut the git exercises or the undo.

Run sheet: Friday 09:00–13:00

Time Block Minutes Notes
08:30 Install drop-in 30 Ludvik: Thursday’s stragglers, and anyone new.
09:00 Welcome back 5 Parking-lot answers from Thursday.
09:05 What it knows about you 25 knows. The field slides first: ask, and let Leonardo write their examples down.
09:30 Take a paper apart 45 paper. Demo 10, hands-on 25, round-up 10. Interview papers welcome.
10:15 Break 10
10:25 Interviews 35 interviews. Codebook, coding, every quote checked.
11:00 References 30 refs. The “right now” slide, the search exercise, then the claim check on their paper folder.
11:30 Break 5
11:35 Words you’ve heard 30 words. Hands up per tile; do the top three or four, five minutes each.
12:05 Your own work 20 own. Open lab. Walk the room.
12:25 Teaching (optional) 20 teaching. The rest carry on with their own work.
12:45 Before you go 15 “What will you try on Monday?” Three answers aloud. The rest of the parking lot.

When behind on Friday: shorten the paper round-up and the words (two words is fine), never the interviews. Own work can shrink to nothing; the handout has it.

Module cards

Get it running

  • Aim: a blinking cursor that answers, and git --version that answers, on every laptop.
  • Floor: make a file, read it back, delete it.
  • Git is required now. If someone has no admin rights, the agent installs the portable Git for Windows into their user folder. Untested on a BI-managed laptop: try it before Thursday. If it fails on the day, they pair with a neighbour for the git steps.
  • Watch for:
    • the “x86” PowerShell;
    • skipping “close and reopen”;
    • Command Prompt instead of PowerShell;
    • Codex’s admin or sandbox prompt (choose unelevated);
    • git needing admin rights (the portable route, above).
  • People with no subscription pair up. Don’t let them sit idle.
  • Finished first? They’re the help desk. Say it out loud. Or the handout’s early task: a five-forces web page for Norwegian salmon farming (tested 21 October with Codex: about 3.5 minutes, a one-page site, opened in the browser).

Git: save points

About 30–35 minutes, mandatory, straight after setup: 25 short slides and four exercises (the yellow “Your turn” slides). New for Strategy: in Finance people couldn’t see how git differs from Dropbox or OneDrive.

  • The framing: mainly for the agent, very good for you too. Four lines on what git is, then where it comes from (a timeline, two charts), so it reads as the tool the software world runs on, not a quirk of mine. Keep moving: most slides are one idea.
  • Talk, exercise, talk, exercise:
    1. A first save point (3 min): git set up, a commit, “what changed?”.
    2. Undo (2 min): revert, the history. “Done early?” is a branch.
    3. A research project (10 min): props/founders-study.zip, tidy, write a .gitignore with explanations, commit, then the privacy check.
    4. Ask (1 min): pick a word from the chips, ask what it means.
  • “What a save point is” is the slide people missed in Finance: what a save point has to do with the files on their computer. Two clicks: commit (a full copy of every file goes into .git), then revert (a copy comes back out over the files). Say: the files you see are always the current version. Delete .git and the history is gone, the files stay; copy the folder and the history comes along.
  • The OneDrive slides are the ones to slow down on: the per-file versions vs whole-folder snapshots diagram, then “40 restores vs one sentence”. The line: OneDrive is a backup, git is a lab notebook. Keep both.
  • The theme for all jargon: unsure what a word means? Ask. The chips slide is there to make the vocabulary look harmless, not to be learned. Worktree is the example because agents use it a lot (Claude Code has --worktree; parallel agents each get one).
  • The .gitignore exercise (key: scratch/examples/founders-study/README.md). The folder has named transcripts, audio, consent forms, a survey with e-mails, a 7 MB registry file, fake PDFs, a fake API key and junk files. Tested 20 October with Claude Code (one combined prompt, no approvals): 81 seconds; it moved everything sensitive into an ignored local/ folder, explained each line, and on its own raised the two “v3 FINAL” drafts, the quotes in coded_excerpts.csv, and the pilots. Those three are the round-up.
    • The bridge to the next deck: ignored by git is not hidden from the agent. It read the transcripts to sort them.
    • The download link only works once Strategy is merged to main and pushed. The zip is also in course-files.zip under practice/.
  • “Revert to the last commit” was tested on 20 October with Claude Code 2.1.302 and Codex 0.162: both discarded the uncommitted change and nothing else. Claude also saved a backup patch first. “Revert the last commit” (no “to”) would undo the commit itself; that’s the small print on “You’ll hear them back”.
  • GitHub Pages: free for public repositories on the free plan (GitHub’s plans page, checked 20 October). The course page is one: say so, and say how little it took. Most teaching and personal pages are fine public. For private repositories, academics can get GitHub’s academic plan (GitHub Education); the exact terms weren’t checked (the docs pages had moved).
  • The name, if you want a laugh: “git” is British slang for an unpleasant person. Torvalds: “I’m an egotistical bastard, and I name all my projects after myself. First Linux, now git.” (as quoted in Scott Chacon’s Git Internals, about 2008; the original occasion isn’t pinned down).
  • Sources (checked 20 October 2026):
    • Torvalds created git in April 2005 for Linux kernel development, after BitKeeper’s free licence ended; first commit 7 April 2005; Junio Hamano has maintained it since July 2005. Pro Git, §1.2.
    • The survey chart: Stack Overflow Developer Survey 2022, “Version control”, professional developers (53,374 answering): Git 96.65%, SVN 5.96%, “I don’t use one” 1.38%, Mercurial 1.22% (multiple answers allowed). All 71,379 respondents: Git 93.87%. Don’t say it’s the latest survey that asked.
    • For a laugh, if it fits: in the 2018 survey, 7.9% of developers still listed “zip file back-ups” and 7.9% “copying and pasting files to network shares”. That is how most of us still work.
    • Windows on git: 3.5 million files, about 300 GB, about 4,000 engineers; “the largest Git repo on the planet” is Microsoft’s own title. Brian Harry, Microsoft DevBlogs, 24 May 2017.
    • The GitHub chart, milestones GitHub announced: over 40M developers (Octoverse, November 2019), 56M (December 2020), 100M (January 2023), over 180M (Octoverse 2025, 28 October 2025; 630M repositories). GitHub also said “over 150 million” in August 2025; it’s left out because it’s a rounded milestone that makes a fake jump to October. Microsoft bought GitHub in 2018 for $7.5 billion.
    • 2021 on the timeline is GitHub Copilot (technical preview, June 2021), which ran on OpenAI’s Codex model, trained on public GitHub code (the Codex paper: 54 million repositories; Chen et al. 2021). Not today’s Codex agent.
    • Codex: “requires commands to run inside a Git repository to prevent destructive changes” (OpenAI, non-interactive mode docs; the override is --skip-git-repo-check). The error on the slide is real (Codex 0.162).
    • Claude Code checkpoints: “Checkpointing does not track files modified by Bash commands.” (code.claude.com, Checkpointing).
    • Zenodo archives a GitHub release and gives it a DOI. The AEA Data Editor describes the route, but doesn’t count GitHub alone as a trusted archive.
  • Handle with care:
    • Copilot and training: GitHub says Copilot won’t train on the repositories it indexes; what you send to Copilot on a personal plan can be used for training unless you opt out (since 24 April 2026).
    • Git inside OneDrive is advice, not established fact: no official Microsoft or git source was found that says it breaks.

What it can touch

About 20–25 minutes, straight after git: 19 slides, three exercises. New for Strategy: in Finance the room was far more worried about access than expected, and got worked up when the agent opened the PDFs in the cleanup.

  • Why Finance got worked up: since Claude Code 2.1.283 (September), auto is the starting mode for interactive sessions on every plan. Reading files in the folder needs no question, so the agent simply opened the PDFs. Say this out loud: it explains what they saw.
  • The stance, plainly: lots of access, on purpose (my own defaultMode is auto). The 50th “yes” is never read; git makes mistakes cheap; auto mode stops what matters. Restrict the few things that matter, mostly by keeping them out of the folder.
  • Exercises:
    1. Where am I? (2 min): see the mode, Shift+Tab, ask what it may do unasked.
    2. A fence around the interviews (5 min): a deny rule in founders-study, restart, try to read a transcript.
    3. Check your switch (1 min): the training setting on their own account.
  • What we tried (20 October, a throwaway folder, claude -p with every prompt refused, so “asks” shows as blocked; Codex exec in workspace-write):
    • Claude, manual: reads in the folder and read-only commands (ls, git status) run; reading elsewhere (even via cat), writing, deleting and web pages all ask.
    • Claude, auto: edits, Python, reading outside the folder (interactive sessions ask once first, with four choices), a web page, rm -rf data, even git reset --hard && git clean -fdx went ahead. Posting a file to an outside address was stopped: “denied by the Claude Code auto mode classifier. Reason: [Data Exfiltration]”.
    • “Revert to the last commit” also works in auto mode (tested): the classifier weighs what you asked for. The docs list git restore . as blocked by default, so the explicit request is what makes it go.
    • Codex sandbox (Linux): reads anywhere, writes in the project and /tmp, a write to the home folder failed (“read-only file system”), network off.
    • The deny rule Read(./interviews/**): blocked Claude’s Read, cat, cp and a Python one-liner, but grep -r Kari . printed the transcript. Hence “a fence, not a wall”.
  • Sources (official docs, checked 20 October 2026):
    • Permission modes, starting mode, Shift+Tab order, auto mode’s blocked and allowed lists: code.claude.com/docs/en/permission-modes. Auto works on all plans with recent models; Team and Enterprise admins can switch it off.
    • Settings files and rule syntax (deny, then ask, then allow): code.claude.com/docs/en/permissions and /settings. On Windows, ~/.claude is %USERPROFILE%\.claude.
    • Claude’s shell sandbox: off by default, and “On native Windows, Claude Code runs commands unsandboxed” (WSL2 needed). code.claude.com/docs/en/sandboxing.
    • Training: one consumer setting covers Claude Code; retention 5 years with training on, 30 days off. code.claude.com/docs/en/data-usage.
    • Codex presets (Ask for approval, Approve for me, Full access), the auto-review reviewer agent, permission profiles that can deny reads, the Windows sandbox (elevated and unelevated; unelevated can’t deny reads): learn.chatgpt.com/docs/sandboxing, /permissions, /windows/windows-sandbox.
    • ChatGPT: training controls apply to Codex; Business, Edu and Enterprise don’t train by default. help.openai.com, “Using Codex with your ChatGPT plan”.
  • Handle with care:
    • Labels on the settings pages (“Help improve Claude”, “Improve the model for everyone”) weren’t verified for October 2026. That’s why the exercise sends people to the page instead of naming the switch. Check your own account before Thursday.
    • “It sends what it reads” is the honest short version, not a guarantee: a command’s output can include many files, and connectors add other data flows.
    • Personal data: don’t claim what BI’s rules say unless you’ve checked. “Your consent forms and data plan decide” is safe.
  • If someone asks about --dangerously-skip-permissions: it skips all checks; only for a throwaway machine. Not something to try on a work laptop.

Do something tedious

About 25 minutes. The prop is props/decrap-me.zip, a synthetic WISEflow export: 15 group submissions with junk file names, cover sheets, and an empty grade sheet in submission order.

  • Aim: a reorganised folder, a grading table, and one deliberate undo.
  • The framing: a job the chat window can’t do, because it can’t touch your files. Tedious, local, easy to judge.
  • Names only (new for Strategy). Group and participant ID are in every folder name, so the job needs no reading. In Finance the agent opened the PDFs anyway (auto mode reads freely) and the room got worked up. Now the prompts say “Work from the names only; don’t open the submissions”, and the last slide, “You decide what it reads”, makes it the point. It follows straight on from the access deck.
  • The git beat: they set up git an hour ago, so this is the habit, not the lesson. Brief the task, then ask “Before you hit enter, does anything about this make you nervous?” Answer with “Set up git here and commit everything.”
  • The undo is on purpose: delete the Marking guidance folder, then “revert to the last commit”. Watching it come back is what makes git stick.
  • Done early? Rename the fake papers in founders-study/literature/ and make a .bib, without opening interviews/. The opposite case: there it has to read, and that’s fine.
  • Ties forward: “Leave a trail” and the GitHub demo reuse the same save-point move.

What it knows about you

About 20 minutes. Two halves, framed honestly.

  • Opens with the field, as I imagine it (new for Strategy, 3–5 minutes). Three cards: interviews and cases, regressions on firm data, “is it just luck?”. Say plainly that you’re a statistician guessing. Then “Tell me what I got wrong”: ask what’s missing and who is which, and write their examples on the parking-lot board. Use those examples in the paper and referee blocks instead of yours. The last line, “the agent is in the same spot”, is the bridge into the deck.
    • Sources for the cards: Burgelman’s Intel fieldwork (Strategy Is Destiny, 2002; “Fading Memories”, ASQ 1994); Eisenhardt (1989), “Building theories from case study research”; the diversification discount (Campa and Kedia 2002, Villalonga 2004); luck and the CEO effect (Denrell and Liu 2012, Fitza 2014, Henderson, Raynor and Ahmed 2012). Background in scratch/links/strategy-canon/.
  • “Who you are” is an open question for this room. In stats, in the terminal, you barely notice it; fields with schools may differ. Say exactly that, and let the room find out. Pairs pick opposite schools on “Is strategy mostly planned, or does it emerge?” (Ansoff and Porter vs Mintzberg and Burgelman). The round-up is data: did it change, and how much?
    • Tested 21 October (Codex, three clean profiles): all three answer “both”. The profile changes the emphasis and the vocabulary, not the verdict: the planning profile defends deliberate direction and boundaries; the process profile explains it through Burgelman’s induced and autonomous processes. So expect “it changed the framing”, and ask the room whether that matters.
    • Another question that splits schools: “How much does the CEO matter for firm performance?” Tested the same day: every profile says “a lot, but no single number”; a Denrell-and-Fitza profile leads with luck, an upper-echelons profile with the bigger estimates.
  • The Berger demo is the tested example of a school changing the answer. The A/B question with no profile, then one line in the folder’s AGENTS.md: “My intellectual idol is Jim Berger.” /clear, ask again. (Tested with CLAUDE.md; Claude reads AGENTS.md the same way as long as there’s no CLAUDE.md in the folder or above it, so demo in a clean folder.)
    • Demo on Claude: Codex ignored the one-liner in testing.
    • The backup result is on the slide after the demo.
    • If a statistician objects that 0.91 is just 1 minus the one-sided p: they’re right; under a flat prior it’s the same information. The point is that the headline, the framing and the recommendation flip.
  • “How you work” is the reliable win. The slide shows two lines from your own profile files (the 4-core rule, MathML). Your terminal profiles hold no “who I am” at all, only working rules, and you can say so.
  • The “who you are” profile belongs in the chat apps. The homework slide says so, with your chat profile as the example. The coffee table (“Four askers”) is in more.html#/chat if someone wants the chat-app version.

Take a paper apart

  • Your demo: a paper you can judge. Ask the three questions, and push at least once on camera.
  • Say these two sentences, no slide:
    • when the first answers come back: “It turned the PDF into text before it could read it”;
    • when the fix runs: “That script is the record of what it did.”
  • Snags:
    • SSRN returns 403 to the agent: download in the browser, then “move it here”.
    • The fix needs Python; let it install.
    • Codex on bare Windows may need a PDF tool; say yes.
  • Watch for:
    • People skip “Do they address it anywhere?” and report false alarms. Collect one for the round-up.
    • Generic first answers are normal; “what’s specific to this paper?” fixes most.
  • Honest framing: “I can’t tell you whether a critique of a strategy paper is right. You can.” If it fails on someone’s paper, say so in the round-up. That’s a result too.
  • From the September pilots on two NBER finance papers:
    • the critique took 1–1.5 minutes, the fix 5–7.5;
    • the two tools picked different “biggest problems” in the same paper.
  • Case studies and interview papers work too, with different pushes (on the slide): “Which claims rest on the fewest interviews?”, “What else would explain the same quotes?” The “fix” is then a design (a comparison case, a sampling rule), not code.

Interviews

About 35 minutes, for everyone, on Friday after the paper. New for Strategy: the invitation promises qualitative work, and Birgitte asked for both traditions. props/pivot-interviews.zip: eight fictional, pseudonymised interviews (F01–F08) with founders who changed direction early, and the interview guide. Built from scratch/examples/pivot-interviews/; the key is KEY.md there.

  • Aim: a codebook they argued with, coded excerpts, three themes, and every quote checked by a script.
  • Four short exercises: is it really anonymous (5), a codebook (8), code all eight and find themes (10), check every quote (5). Then the pushes, and the “who does what” slide.
  • What’s planted (don’t say beforehand):
    • three pseudonymisation slips: a co-founder’s first name in F02, the investor’s full name in F05, and F07’s firm, identifiable from its description;
    • a contradiction in F03: “the investors had no influence”, then the board pushing hard;
    • F04 calls the change planned in question 4, after telling a chance meeting at a trade fair in questions 2 and 3: planned or emergent, from knows;
    • F06 never pivoted: the case that doesn’t fit.
  • Tested 21 October (Codex, clean profile, prompts exactly as in the handout): about five minutes of agent time in all. The anonymity check found all three slips plus softer combinations of details (51 s); eight codes with boundaries (29 s); 187 coded excerpts (51 s); three themes (53 s); the quote check passed all 187 (32 s); the push found F06, F03’s contradiction and F04’s trade fair (27 s).
  • The quote check is the payoff. It’s the qualitative version of “rerun the code”: cheap, mechanical, and it makes the rest trustworthy. In the test every quote matched; if someone’s doesn’t, that’s the best possible round-up.
  • Real transcripts: only if their data plan allows a model to read them. Pseudonymised copies, in a folder of their own. Point back to the access deck.
  • Ask the qualitative people what they’d do differently, out loud. The invitation says they’re especially welcome to share what works.

References

Friday: 30 minutes, mandatory. The “in the literature right now” slide (3), the search exercise on their own question (10), then the claim check on the paper folder from Take a paper apart (15): the slide’s “papers not in the folder yet?” prompt downloads three cited papers and checks them. DOI check and the rest are in the handout. The full module is 40 minutes for two parts, 60 for all four.

  • Search. Tell the story first: shallow, specific questions have turned up important papers you didn’t know, in your own field (the Hjort–Glad prompt). Then the exercise, about 10 minutes: everyone asks one specific question about their own idea, and has it download the papers. The lesson is be specific. Deep (“I need every method since 1995…”) is a different request: finalizing, slow, and expensive on usage. Show the prompt; don’t run it in the room.
  • Papers in the folder. The practice to sell hardest in this module: one rule in the project file (papers go in literature/; download what you can, a DOI for the rest), and the agent stops searching for the same paper again and again. It’s also what makes the claim check work.
  • DOI check. The practice .bib has six planted traps. The full key is in scratch/examples/references/README.md. Floor: three DOIs pasted into doi.org by hand.
  • Claim check. The centrepiece. Run it on their own draft if they have one, after the papers are in literature/. “Not in the folder” is not “doesn’t exist”.
  • The line to end on: a polished bibliography is not evidence of a correct bibliography.

Words you’ve heard

About 30 minutes on Friday, replacing Finance’s research menu. Nine tiles; for each, ask “who has heard this and never quite understood it?”, count hands, and do the top three or four, five minutes each: the picture, one sentence, the prompt to try.

  • New sections in the deck: skills, subagents, plan mode, context and /compact, worktrees, agents in the cloud. Their own decks (coral tiles): connectors (mcp), the project file (agents), GitHub (github, with the pull-request demo with Ludvik).
  • Checked 21 October against Claude Code 2.1.304 and Codex 0.163: both have subagents, plan mode, /compact, and a worktree flag (claude -w, codex --worktree); Codex’s cloud tasks are marked experimental in the CLI. The skills and subagents prompts use the pivot-interviews folder from the morning.
  • Tested 21 October (Codex, on pivot-interviews): the subagents prompt took 73 seconds, really used one helper per transcript, and returned the table (F06 flagged as “no change”). The skills prompt wrote a good check-quotes/SKILL.md in 27 seconds. Saving it goes to the user’s skills folder, outside the project, so expect a permission question: say yes. That’s Thursday’s access deck in action.
  • End on the last slide: any other word? Ask the tool. It’s the same move as Thursday’s “Unsure what a word means? Ask.”

Referee panel, any time

New module, not yet run with a room. About 40 minutes.

  • Aim: two or three independent referee reports from one agreed procedure, plus an editor’s letter.
  • Floor: two reports from fresh sessions, and one concern they hadn’t thought of.
  • The flow (the diagram on the first slide):
    1. Who would referee this?
    2. Ask how it’s done: a procedure, saved to reviews/how-to-referee.md.
    3. /clear, then one referee at a time, following the procedure.
    4. Not right? Change the procedure, not the report.
    5. The editor.
  • The lesson to sell beyond referees: ask the agent how a job should be done before you ask it to do it. It’s the most underused move. Step 2 is the place to say so out loud.
  • Why /clear and not a new window: it’s the same in both tools and needs no window juggling. After the procedure discussion, it’s exactly right: each referee starts with only the paper and the procedure.
    • Parallel sessions are a one-liner for the eager: a second PowerShell window with its own claude/codex, or Claude Code’s parallel subagents.
    • The agent can also start claude -p or codex exec in the background itself. Don’t teach that today.
  • Skill hook: “Turn the procedure into a skill called referee-panel” connects to the skills slide in notes, if anyone asks.
  • Demo: the first two steps on a strategy paper, live. Then one referee from a fresh session.

Leave a trail

About 50 minutes. The full instructor key is in scratch/examples/leave-a-trail/README.md.

  • One story: Reinhart and Rogoff. Economists remember it, so ask the room first: “Who remembers the 90% debt threshold?” Keep it about their own interest, not open science: you want your rerun to find it before a grad student does. The facts, to stay accurate: above 90% debt to GDP they reported −0.1% average growth; Herndon, Ash and Pollin (2013 working paper; Cambridge Journal of Economics 2014) got +2.2%. The Excel range error (rows 30–44 instead of 30–49, dropping Australia, Austria, Belgium, Canada, Denmark) accounts for only about 0.3 points of that; the rest is excluded years and the equal weighting by country. Don’t say the Excel error alone flipped the result.

  • The folder is a practice project, not their paper: Kari Nordmann’s and their survey experiment on price framing (fictional), in props/messy-project.zip. The deck shows the link and the file tree. Those who finish go on to a copy of a real folder of their own, or their paper folder from Take a paper apart.

  • Floor: the rerun test passes after /clear.

  • Opening: a show of hands, LaTeX or Word? LaTeX users already write in text; for them the news is git and the rerun test.

  • The practice folder (props/messy-project.zip) has a planted problem. Three willingness-to-pay outliers were deleted by hand in Excel, with no record. With them in, the effect flips sign and stops being significant. Only the rerun test finds it.

  • The last-but-one slide is the reveal (“What the rerun found”: N = 223, −292 NOK, p = 0.26 with the three rows; N = 220, +53 NOK, p = 0.02 without). Show it only after the room has run the test. The handout only hints at it.

  • Git was set up on Thursday, so the exercise’s first step is one prompt. Anyone who missed Thursday: the agent asks for a name and email at the first commit.

  • The test slide is a diagram with two clicks: “Same numbers, done”, then the loop back (“Not the same? Fix the README, run the test again”).

  • Not yet piloted with an agent end to end.

Notes and structure

About 20–30 minutes; lighter than the rest.

  • The four questions come from the tidy-project skill in this repo (.claude/skills/tidy-project/SKILL.md). It’s a good live demo if someone asks “what does a real skill look like?”
  • “My paper folder” is your paper-init layout (five folders: manuscript, code, results, dev, local), simplified: no justfile, Modal or Slurm. Say it’s a skill, which sets up the skills slide at the end.
  • “dev/ or local/?” is the one distinction worth slowing down for: dev/ is committed (backed up on GitHub, co-authors see it) but never published; local/ is in .gitignore, so git and GitHub never see it. It’s also the natural place to say what .gitignore is.
  • Question 3 (“where are you allowed to be wrong?”) is the one people stall on, and the stall is informative.
  • The log habit (notes/log.md, then “tell me where we left off”) is the most useful thing in this module for people who’ll use the tool weekly.

Skills, if asked

Not taught. One slide at the end of the notes deck (notes.html#/skills) and a box in the handout.

  • The line: memory is the AI remembering you; a skill is you writing it down.
  • When it’s worth it: a routine you repeat, want identical every time, or want to hand to a colleague.
  • Live demo if pushed: open the tidy-project skill and show it’s a page of plain English. Or, after any module: “Turn what we just did into a skill called X”, and show the file it wrote.

The project file, if asked

  • The deck: agents.html, about 10 minutes. The short version is already the last content slide of notes, and “Two files” in knows.
  • The practical answer people want: one file, AGENTS.md. Codex always read it; Claude Code reads it since v2.1.277 (18 September 2026), but only when there’s no CLAUDE.md in the folder or above it. An older repo with a one-line CLAUDE.md saying @AGENTS.md (like this course repo) still works.
  • Changes go through the agent: “Add to AGENTS.md: …”. Nobody needs to open the file in an editor, though they can.
  • The habit worth selling: “Add that to the project file” after the second identical correction.
  • /init: fine as a shortcut, but the draft only describes the folder. The rules are the valuable part, and only they can write those. Claude Code’s /init writes a CLAUDE.md, which would then hide the AGENTS.md: ask for AGENTS.md by name instead.
  • The gotcha: both tools also read project files from the folders above. Starting the agent in Documents with a stray AGENTS.md there affects everything below it.

GitHub, if asked

  • The deck: github.html, about 10 minutes; section 15 of the handout.
  • The one-liner: git is save points on your laptop, GitHub is the copy in the cloud. OneDrive syncs files; GitHub keeps every version and who made it.
  • Setup is one prompt once they have an account: “Install the GitHub command-line tool and log me in.” On Windows the agent runs winget install --id GitHub.cli -e, then gh auth login, which opens the browser. Not tested on a BI-managed laptop; if winget is blocked, the installer is at https://cli.github.com.
  • The selling point for research: replication packages. A repository archived on Zenodo gets a DOI.
  • Say once: private by default; history is forever, so data and passwords never go in.

The pull-request demo, with Ludvik

About 10 minutes, live. It shows what collaboration looks like when neither of you types a git command.

Done live, from scratch. No pre-made repository. If something breaks, narrate the fix: watching the agent recover is part of the lesson.

Before Thursday: Ludvik has a GitHub account, and gh installed and logged in. Have his username ready.

Setup, live (2–3 minutes): in a copy of the “Leave a trail” practice folder (props/messy-project.zip): “Set up git, commit everything, put this folder on GitHub as a private repository called strategy-demo, and add [Ludvik’s username] as a collaborator.” Ludvik accepts the invitation (it comes by email), then: “Download JonasMoss/strategy-demo into this folder.”

The pull request:

  1. You, first: start the watcher in Claude Code and let it sit: /loop 1m check for new pull requests on this repository; when one appears, summarise it. Test /loop beforehand. If it misbehaves, just ask “any new pull requests?” when Ludvik says he’s done.
  2. Ludvik, on the projector or his own screen, dictates or types: “Make a new branch, add the missing rule to the cleaning (drop willingness to pay above 5,000 NOK; it was done by hand in Excel and never written down), rerun the analysis, commit, push, and open a pull request to Jonas explaining what you changed and why.” The practice folder has no cleaning script, so his agent writes one. That’s fine, and it’s a bigger change to review.
  3. You: the watcher reports it. Then: “Check out the pull request and test it. Rerun everything from the raw export: do we get table1 (N = 220)? And what happens without the new rule?”
    • With the rule: N = 220, +53 NOK, p ≈ 0.02. The hand-cleaned file is now reproducible from raw.
    • Without it: N = 223, the effect flips sign (about −292 NOK) and stops being significant.
    That’s why the rule has to be written down. Then: “Comment: good catch, add the rule to the README too.”
  4. Ludvik: “Address Jonas’s comment and push.” You: “Merge it.”
  5. Show the pull request page in the browser: the description, the comment, the commits, the merge. “That page is the whole history of the decision.”

Then the pairs exercise (deck slide “Exercise: in pairs”, handout section 15), about 15 minutes: A puts a folder on GitHub and adds B; B accepts, downloads, and opens a pull request; A reviews and merges; swap. Everyone needs a GitHub account and gh logged in first, which is the slow part: start that during the demo. Accepting the invitation through the agent goes through the GitHub API (gh api user/repository_invitations); if the agent fumbles, the invitation email has a button.

Optional, if set up beforehand: comment @claude (or @codex review) on the pull request, and let the room watch a review appear on GitHub. This needs the Claude GitHub app (/install-github-app in Claude Code) or Codex’s GitHub connection on the demo repository. Not yet tested.

Your own work

  • Walk the room. Ask “what are you trying?”, not “is it working?”
  • Stuck people: suggest “What’s here? What’s missing? What would you do first?” on a real folder, after a commit.
  • The luck-test card is the one to push for this room: no data, a classic strategy question (Henderson, Raynor and Ahmed 2012, “How long must a firm be great to rule out chance?”), and a punchline people find themselves.
    • Tested 21 October (Codex, 52 seconds): 1,000 identical firms, a 50–50 year each, 30 years. 51 beat the benchmark in 20 of 30 years by pure luck (49 expected); 8 had a 10-year winning streak; the longest was 14 years. Searching all firms and start years, an 18-year streak is the 5% bar, 20 years the 1% bar. Chosen in advance, 5 to 7 years would do. That last contrast is the point: picking the winners afterwards is what changes the arithmetic.
    • Good follow-ups: “Now let skill differ a little. How often does the most skilled firm come out on top?” (Denrell and Liu’s question.)
  • Close: “What will you try on Monday?” Get three answers out loud. Remind them the handout has everything, including what we skipped.

Teaching

Optional, about 20–25 minutes at the end of Friday, while the rest carry on with their own work. Birgitte asked for it to be short: several of them have taken BI’s AI-for-teaching course. So only what the terminal adds to the chat: the whole course folder, files out, reruns next year.

  • The exam factory (from the old course-factory handout): five lines about the course, out loud; twelve questions at three levels and a rubric; then “Which learning outcome can’t be assessed as it’s written?” That’s the payload.
  • No course at hand: props/ORG3402-organisational-behaviour.md, a fictional bachelor course. Three of its eight outcomes are vague on purpose (K2, S3, G2); the rubric for K2 comes back as “excellent / good / some / limited understanding”, which is the point. More in scratch/examples/syllabus/README.md.
    • Tested 21 October (Codex, on the fictional syllabus): questions and rubric, then the outcome question, in 114 seconds. It named G2 first, then K2 and S3: all three planted ones.
  • A course page, then GitHub Pages, ties back to Thursday’s git deck.

Questions you’ll get

The longer prepared answers are in scratch/august-course/grievance-answers.md. The short versions:

  • “Is my data safe?” What it reads is sent to the company, like any cloud upload. Keep out personal data and confidential material.
  • “Can it read my email?” Yes, through connectors (MCP): Gmail, Google Calendar and Drive connect in a few clicks at claude.ai/customize/connectors, and Claude Code picks them up (/mcp lists them). Deck: mcp.html, five slides. BI mail is Outlook: a Microsoft 365 connector exists, but BI IT would likely have to approve it (not checked). Don’t demo on your own work mail.
  • “Does it train on my data?” It depends on the plan and changes over time, so check your plan’s terms. When unsure, assume it could be retained.
  • “Claude or ChatGPT?” Both are excellent. Use the one you pay for. They aren’t interchangeable, so trying both on the same task is instructive.
  • “Will the department pay?” That’s a question for Dagfinn. Marketing reimburses its people via its administration.
  • “Can I get the slides?” Yes: each deck is one file. Zip decks/*.html and send them to Dagfinn afterwards with the handout. Open menu.html first.