Getting Work Done with AI Agents - A Short Course

As a foundation for the course, you will receive an accessible introduction to what makes file-aware agents different from ordinary chatbot use. We will cover how agents such as Codex and Claude Code can work inside folders, read and revise files, run checks, update logs, and leave behind inspectable traces of what they did.

We will then turn to the design of an agent-readable workspace. You will learn how to organize source materials, project notes, outputs, logs, examples, corrections, standards, and review records so that an agent can understand the project and work with less repeated explanation.

A significant amount of seminar time will be devoted to the working loop at the center of the course:

do work → log → learn → automate

You will do real work with an agent, log what happened, identify useful patterns, and turn those patterns into repeatable instructions, templates, workflows, skills, or automations.

The final part of the course covers delegation and scaling: breaking larger research or professional tasks into bounded agent assignments, setting review checkpoints, preserving human judgment, and building a first playbook for working with AI agents across projects.

You should use a laptop with access to a file-aware AI agent tool. For the hands-on exercises, you will need either Codex or Claude Code so that the agent can work inside a folder of project materials.

The main demonstrations will use Codex. If you already use Claude Code, you are welcome to use it instead, since the core ideas apply to both tools.

If you are a first-time user, Codex is likely to be the smoother starting point, especially with a paid subscription that supports file-aware agent work. Claude Code can also work well, but it may require more setup depending on your system and prior experience.

We will also refer to common AI chat tools such as ChatGPT, Claude, and Gemini for comparison, but ordinary chatbot access alone will not be enough to complete the core exercises as designed. Some examples may use Google Drive, Microsoft Word, PDFs, spreadsheets, Markdown files, and a local folder of course materials.

No prior programming experience is required. If you already use R, Python, or another coding environment, you’re welcome to bring that into the exercises, but the core course activities will focus on research workflows that can be done through files, documents, notes, and agent instructions.

To summarize, recommended setup before the course includes:

• • A laptop with a modern browser
  • Access to Codex or Claude Code for file-aware agent work
  • Strongly recommended: a paid subscription that supports one of these tools, especially Codex for first-time users
  • A folder where you can save course files and create a small project workspace
  • Optional: Google Drive, OneDrive, Dropbox, or another cloud folder used in your research work
  • Optional: RStudio, VS Code, Python, or another familiar coding environment

Given the rapidly changing AI landscape, platforms and API access requirements may change before the course begins. We will provide up-to-date setup guidance before the seminar, including recommended AI tools, account requirements, and any estimated API costs for course exercises.

This course is designed for faculty, graduate students, postdocs, analysts, and research staff who want to use AI agents as part of ordinary research work. It is especially relevant for people who work with documents, literature, notes, datasets, code, grant materials, teaching materials, or complex project folders.

No programming background is required. If you code, you will be able to apply the same principles to coding workflows, but the course is designed to be useful for researchers whose work is primarily document-, project-, and writing-heavy.

This course focuses on building a practical agentic work system. It is more operational than AI Agent-Driven Research Workflows and less programming-focused than LLM Agents for Research Using R.

Day 1: From chatbot use to agentic work

What changes when an agent can work inside a project?

• • How file-aware agents differ from ordinary chatbot use
  • What agents can do with folders, documents, code, notes, and outputs
  • Why project context matters for reliable agent work
  • Hands-on practice: turning a messy research task into a bounded agent request

Setting up an agent-ready workspace

• • Organizing source materials, working notes, outputs, and logs
  • Creating a project context map that tells the agent where to look
  • Distinguishing agent output from project truth
  • Hands-on practice: creating or refining a first agent-ready project folder

Running and reviewing a bounded task

• • Asking an agent to summarize, compare, inspect, outline, or draft from project materials
  • Reviewing the output for accuracy, relevance, provenance, and fitness for purpose
  • Recording what happened in a short log entry
  • Take-home exercise: run one bounded task and log the task, inputs, output, review notes, and next step

Day 2: Logs, context, and reusable workflows

Learning from the trace of work

• • The do work → log → learn → automate cycle
  • Why logs are the primary learning trace for agent-assisted work
  • What should be logged and what can be left out
  • Hands-on practice: turning a messy work session into a useful log

Project memory and source discipline

• • Writing project documentation that agents can actually use
  • Preserving source provenance and avoiding unclear sources of truth
  • Using examples, corrections, standards, and checklists as agent memory
  • Hands-on practice: revising a project context map or README

Turning repeated work into reusable workflows

• • Identifying recurring research tasks that are ready to systematize
  • Writing workflow notes for literature scans, memo drafting, document extraction, grant preparation, teaching preparation, data review, or project planning
  • Specifying inputs, agent role, human review points, outputs, and known failure modes
  • Take-home exercise: convert one repeated task into a reusable workflow note

Day 3: Delegation, review, and automation

Designing larger agent-assisted workflows

• • What makes a task agent-shaped
  • How to decompose complex work into smaller units
  • How to define inputs, outputs, context, review points, and risks
  • Hands-on practice: decomposing one larger research task into agent-shaped subtasks

Delegation and review

• • Using an agent session as a project assistant or chief of staff
  • Running sequential or parallel agent tasks while preserving review checkpoints
  • Deciding what should be delegated, what should be automated, and what should remain human-reviewed
  • Hands-on practice: designing a review plan for a multi-step agent workflow

Building a personal or team agent playbook

• • Pulling together folder conventions, logs, context maps, workflow notes, and review rules
  • Choosing which workflows to refine after the seminar
  • Identifying one candidate automation or delegation pattern
  • Take-home exercise: a first personal or research-group playbook for working with AI agents