DHSI 2026

DH Programming Pedagogy in the Age of AI

─────────────────────────────────────────

Anastasia Salter & John T. Murray

June 8–12, Montréal

$ student-projects --showcase [+][-]

What the 2026 cohort shipped in one week — most participants starting with little or no coding experience. First, the week in two minutes and forty-five seconds: an affectionately chaotic recap video (terminal aesthetic, robot voices, and the mid-class launch of Fable 5, exactly as we lived it). Captions included.

Demo Day projects — all live, all built during the workshop:

  • btscan — a minimal Bluetooth Low Energy scanner: who’s broadcasting in this room? Surveillance, made visible.
  • Evil I — detecting unreliable first-person narrators in eighteenth-century British texts, entirely in the browser.
  • Penny Runner — a very good dog adventure (pixel platformer).
  • UMN Ed Tech Transparency Project — what are the rules for AI and technology on campus? Every answer links to a verified source.
  • Smash the Patriarchy — each monster is a word; break the word and it shatters into the smaller things that made it.
  • Feminist Theory into Practice — name a problem of gender inequality, get back one real thing people have built to confront it.
  • Building a Local Patent Database — 12M+ patents from public-domain sources, running entirely on your own machine.
  • Archive Prep Tools — a local suite for preparing audiovisual and tabular archive materials; no audio or data leaves your Mac.
  • Pixel’s Code Quest — learn Python alongside a cat in the browser, powered by Pyodide.
  • CMA Education Search — type a topic or paste curriculum language and get Cleveland Museum of Art artworks aligned to Ohio social studies standards, each with the connection explained.
$ course --description [+][-]

This workshop guides humanities scholars through the emerging landscape of agentic coding—building functional tools and applications through collaboration with AI, rather than writing code from scratch. We begin with Claude Artifacts for rapid prototyping and Claude Code Web for browser-based development, then transition to the Claude Code CLI for the remainder of the week. Participants will work through Simon Willison’s agentic engineering framework, learn to build and share reusable skills using the Superpowers methodology, integrate external tools via the Model Context Protocol (MCP), and deploy smaller open-source models from Hugging Face for specialized tasks like transcription. The final deliverable is a working tool with either a local model or MCP integration relevant to participants’ own research and teaching.

No prior programming experience is required—but bring curiosity, a laptop with admin access, and a willingness to think critically about what it means to build with AI.

$ course --prerequisites [+][-]
  • Claude Pro subscription — Required for full access to Artifacts, Code Web, and Claude Code CLI. Sign up at claude.ai.
  • GitHub account — Use a .edu email if possible for GitHub Education benefits. Create one at github.com.
  • Visual Studio Code — Install from code.visualstudio.com.
  • Git — Install from git-scm.com. Required for version control in agentic workflows.
  • GitHub Desktop (optional) — A visual Git client if you prefer not to use the command line. Install from desktop.github.com.
  • Claude Code CLI — We will walk through installation on Day 2, but you can get started early by following the setup guide.
  • Ollama — For running local models. Install from ollama.com. We will configure it on Day 2, but having it installed in advance saves time.
  • Administrative laptop access — You will need to install software during the workshop.
$ course --readings [+][-]

Complete these before the first session. They provide the conceptual framework we’ll build on all week.

$ day-1 --am [+][-]

Session 1: Positioning and Prototyping with Artifacts

Session recap: Day 1 AM Recap — Why Agentic Tools, Not Chatbots

Slides: Introduction — Pragmatic Agentic AI in the Digital Humanities

Demo: Distant Reading with Claude Projects

Readings:

Topics:

  • Welcome and introductions: who’s in the room, what do you want to build?
  • The agentic coding spectrum: vibe coding → distant coding → agentic engineering
  • Willison’s framework: what changes when code is cheap to write?
  • Hands-on: distant reading with Claude Projects and Artifacts — moving a small corpus through a stopword → bag-of-words → key phrases → network → comparative pipeline and visualizing the findings (Distant Reading with Claude Projects)
  • Discussion: what does the distant view reveal, where does it hit a wall, and where does Claude get it wrong?

Exercise: Work through the Distant Reading with Claude Projects demo with a different set of texts of your own, using Claude Projects and Artifacts. Generate at least five visualizations, and document one place Claude got it wrong.

$ day-1 --pm [+][-]

Session 2: From Artifacts to Claude Code Web and GitHub Pages

Demos:

Session recap: Day 1 PM Recap — From Artifacts to Claude Code Web and GitHub Pages

Readings:

Topics:

  • From Artifacts to Code Web: when you need files, persistence, and real deployment
  • The progression we’ll demo: a prompt-built Artifact → an AI-powered app → a version-controlled site on GitHub Pages
  • Walking the three demos above: distant coding, AI interfaces, and deploying with Claude Code for Web
  • Agentic development: plan mode, /init, and iterating with an agent that edits real files
  • Discussion: the spectrum from chat to code — when do you need each tool?

The capstone that builds on these demos — Agentic Code with Claude Code for Web — opens Day 2, where we’ll walk through it together with full time to plan, build, and deploy.

$ day-2 --am [+][-]

Session 3: Claude Code on the Web — Building and Deploying in the Browser

Note on the live session: We didn’t reach the Claude Code CLI this morning — we worked in Claude Code Web instead, building and deploying agentically straight from the browser with no local setup. The Claude Code CLI overview has moved to Day 3 AM. One heads-up from class: there is currently a bug in Claude Code Web’s GitHub connector that requires setting up a personal access token (PAT) to connect your repositories. Generate a token in GitHub (Settings → Developer settings → Personal access tokens) with repo access and use it when prompted to authorize the connection.

Opening walkthrough: We work through the Day 1 capstone we didn’t reach — Agentic Code with Claude Code for Web — together, as a group. We plan, build, and deploy an ambitious public-facing site to GitHub Pages, working agentically with Claude Code Web (plan mode → iterate → deploy), so everyone has the moves down.

Session recap: Day 2 AM Recap — Building and Deploying with Claude Code Web

Readings:

Demos:

Topics:

  • Claude Code Web: building and deploying from the browser with no local install
  • Connecting GitHub: repositories, and the personal access token workaround for the current connector bug
  • Agentic development in the browser: plan mode, iterating with the agent that edits real files, and deploying to GitHub Pages
  • Working through the capstone together: planning, building, and shipping an ambitious public-facing site
  • Discussion: what the browser-based workflow makes easy, and what we’ll gain by moving to the CLI on Day 3

Exercise: Following the Image Metadata with Claude Code demo, gather a set of images you have rights to (personal photographs, public domain, or Creative Commons), create a new repository with GitHub Desktop, and run claude to generate descriptive alt text, rename the files to match their contents, and build a slideshow presenting them.

$ day-2 --pm [+][-]

Session 4: Context Engineering and Local Models

Session recap: Day 2 PM Recap — Ethics, Labor, and the Economics of Local Models

Readings:

Demo:

  • Setting up Ollama, running a local model, and connecting it to Claude Code for a text analysis task

Topics:

  • Context engineering: CLAUDE.md files, project memory, and teaching the agent about your work
  • Git basics for agentic workflows: why version control matters more, not less, with AI
  • Why local models? Privacy, cost, offline access, and running specialized tasks without the cloud
  • Installing and configuring Ollama: pulling models, understanding model sizes and hardware requirements
  • Connecting Ollama to Claude Code: using ollama launch claude and environment variable configuration (Ollama integration guide)
  • When to use local vs. cloud models: the tradeoffs for humanities researchers

Demo: Claude Fable Demo — an educational game teaching the command line, inspired by Carmen Sandiego, generated from a one-sentence prompt (“make an educational game teaching the command line inspired by Carmen Sandiego”) with today’s launch of Fable.

$ day-3 --am [+][-]

Session 5: The Claude Code CLI and the Model Context Protocol

Session recap: Day 3 AM Recap — The Command Line and the Claude Code CLI

Claude Code CLI — Setup and First Principles: We open Day 3 by moving from the browser to the terminal — installing the Claude Code CLI and working agentically from the command line (this overview moved here from Day 2 AM, where we worked in Claude Code Web instead).

  • Installing and configuring Claude Code CLI
  • The terminal as creative workspace: navigating the command line for humanists
  • Opening a repository in the terminal with GitHub Desktop and launching claude
  • Running terminal commands from within Claude: how the agent executes bash, installs packages, and interacts with your file system — and when to let it vs. when to intervene
  • Slash commands: built-in commands (/help, /init, /clear, /compact) and how they structure your workflow (Claude Code CLI reference)

Links

Readings:

Topics:

  • What is MCP? The “USB-C for AI” — connecting Claude to external tools and data
  • The MCP ecosystem: servers, clients, and the community registry
  • Demo: connecting Claude Code to GitHub, a file system, and a web browser via MCP
  • The Zotero MCP: connecting your reference library directly to Claude for citation-aware workflows
  • The Hugging Face MCP: accessing open-source models from within Claude Code
  • Demo: using the Hugging Face MCP to find and deploy a transcription model (Whisper) for archival audio
  • Discussion: what data sources and tools matter for your research?

Exercise: Configure at least one MCP server with your Claude Code installation. Use the Hugging Face MCP to identify a small model relevant to your research (transcription, OCR, classification, translation). Build a simple pipeline that integrates it.

$ day-3 --pm [+][-]

Session 6: The Superpowers Workflow

Session recap: Day 3 PM Recap — Local Models, MCP, and the Superpowers Workflow

Readings:

Topics:

  • The Superpowers framework: Brainstorm → Spec → Plan → Subagent Development → Review → Finalize
  • Installing and configuring the Superpowers plugin
  • The /brainstorm command: Socratic dialogue before code
  • Subagent-driven development: dispatching parallel tasks with built-in review
  • Demo: walking through the full Superpowers workflow on a real DH tool
  • Discussion: structured methodology vs. improvisation — when does each serve humanities work?

Exercise: Use the full Superpowers workflow to brainstorm, plan, and begin implementing your final project tool.

$ day-4 --am [+][-]

Session 7: Building and Sharing Skills

Session recap: Day 4 AM Recap — What You Still Need to Know: Verification, Trust, and Building Your Project

Readings:

Topics:

  • What are skills? Reusable SKILL.md files that encode expertise
  • Anatomy of a skill: frontmatter, instructions, examples, and pressure-testing
  • Building a custom skill for a humanities workflow (e.g., a “distant reading” skill, a “metadata extraction” skill, an “archival transcription” skill)
  • Sharing skills: the community ecosystem and the Anthropic marketplace
  • Demo: authoring, testing, and installing a custom skill

Exercise: Design and write a skill that encodes a workflow from your discipline. Test it by having Claude Code use it on a sample project. Share it with the group.

$ day-4 --pm [+][-]

Session 8: Building Your Tool

Session recap: Day 4 PM Recap — Power Tools for Building: VS Code, Sub-agents, and Remote Control

Readings:

Topics:

  • Dedicated build session: complete your final tool with instructor support
  • Integration patterns: combining MCP connections, local models, and custom skills into a single workflow
  • Troubleshooting and peer review
  • Deployment options: GitHub Pages, local tools, shareable packages
$ day-5 --am [+][-]

Session 9: Presentations and Futures

Readings:

Topics:

  • Participant presentations: demo your tool, explain your process, reflect on what you learned
  • Discussion: what does this mean for how we teach programming in DH?
  • Pedagogical takeaways: designing assignments around agentic coding for your own courses
  • Resources for continuing: communities, documentation, and next steps

Deliverable: A working tool with either local model or MCP integration, deployed or shareable, accompanied by a brief reflection on the process of building it.

Friday PM: Free

$ course --resources [+][-]

Agentic Engineering

Local Models and Ollama

Hugging Face and Open Models

Digital Humanities and AI Pedagogy

Practitioner Blogs