DHSI 2026

DH Programming Pedagogy in the Age of AI

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

Anastasia Salter & John T. Murray

June 8–12, Montréal

$ 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

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: Claude Artifacts for rapid prototyping — building a text analysis tool, a quiz, or a timeline in the browser without leaving the chat
  • Discussion: what can Artifacts do, and where do they hit a wall?

Exercise: Build a small interactive artifact relevant to your research or teaching. Share it with the group. We’ll revisit this project on Day 5.

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

Session 2: Claude Code Web — Beyond the Chat Window

Readings:

Topics:

  • From Artifacts to Code Web: when you need files, persistence, and real deployment
  • Working in Code Web: projects, file management, GitHub integration
  • Demo: building a multi-page GitHub Pages site from a research project
  • Discussion: the spectrum from chat to code — when do you need each tool?

Exercise: Take the artifact you built this morning and rebuild or extend it in Code Web. Deploy it to GitHub Pages.

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

Session 3: Claude Code CLI — Setup and First Principles

Readings:

Topics:

  • Installing and configuring Claude Code CLI
  • The terminal as creative workspace: navigating the command line for humanists
  • 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)
  • Building a custom slash command: creating .claude/commands/ files as reusable prompt templates for your own research workflows (Custom slash commands guide)
  • Demo: setting up a project from scratch with Claude Code, including writing a custom slash command

Exercise: Initialize a new project with Claude Code. Create a custom slash command for a task you repeat often (e.g., /analyze-text, /format-citations, /summarize-source). Use Claude Code to scaffold a basic tool.

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

Session 4: Context Engineering and Local Models

Readings:

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: setting up Ollama, running a local model, and connecting it to Claude Code for a text analysis task

Exercise: Write a CLAUDE.md file that describes your research domain and goals. Install Ollama and pull a small model (e.g., Llama 3.2 3B or Qwen 3). Connect it to Claude Code and compare the experience of working with a local model vs. Claude for a simple task.

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

Session 5: The Model Context Protocol

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

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

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

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