Agentic Coding

101 Exercises: The Landscape

Setup

  • A laptop with a terminal. The examples use zsh.
  • Claude Code, or the time to install it in Exercise 1 by following Anthropic's official setup guide.
  • A small project you know well, under git, with a handful of source files and ideally a test suite. A clone of an open-source project works if you have nothing of your own.
  • Optionally, an assistive tool such as Copilot or Cursor for Exercise 3. Claude Code alone is enough.

Exercise 1: Installation and a First Task (20 minutes)

Objective: Install Claude Code, run a first task whose right answer you already know, and judge the result rather than the agent's report of it.

Instructions:

  1. Install Claude Code by following Anthropic's official setup guide, then confirm it from a terminal with claude --version.
  2. Start from a clean working tree: git status --short should print nothing. Commit or set aside your own changes first, so that every change that follows is the agent's.
  3. In your project's directory, start a session by running claude, and ask the agent to explain the structure of the project. Note what it gets right and what it misses.
  4. Choose a small fix or feature whose right answer you already know. Write down what a correct result looks like, then ask the agent for it.
  5. When the agent says it is done, read the change with git diff and run the tests yourself. Compare the result with what you wrote down, not with the agent's report.
  6. Note anything the agent did that you did not ask for.

Facilitator notes: The first task is for calibration, not productivity, which is why its answer should be known before it starts. Push attendees to judge it by the diff and the tests: an agentic failure can be loud, with the wrong files edited and the tests broken, or as quiet as a report that the work is done when it is not (ACI-001). An attendee whose project has no tests can run the program instead, and should say what they looked at.

Verification: claude --version prints a version on the attendee's machine, and the attendee can show the first task's diff beside the correct result they wrote down before asking, with the tests run or the check they made instead.

Exercise 2: Place Yourself on the Spectrum (15 minutes)

Objective: Place your current use of AI coding tools on the agentic-assistive spectrum, and choose your next step up.

Instructions:

  1. Take the spectrum's four levels, with your role at each:
    • assistive: the AI suggests, and you drive, accepting or rejecting;
    • conversational: the AI answers your questions, and you direct;
    • collaborative: the AI edits files, and you review;
    • agentic: the AI executes a multi-step task, and you delegate and verify.
  2. For each level, write down one task you did at that level in the last month, or "never".
  3. Mark your ceiling: the highest level you use regularly.
  4. Pick one task from this week's work that you could have done one level higher than you did.
  5. Write down the skill that level asks for: recognising good suggestions at the assistive level, asking good questions at the conversational level, reviewing multi-file changes at the collaborative level, and defining tasks, engineering context and verifying outcomes at the agentic level.

Facilitator notes: Push for tasks the attendee has done, not tasks they could do. For an attendee whose ceiling is assistive, the next step is conversational, not agentic: the page holds that jumping from autocomplete to full autonomy is too large a shift of mental model for most practitioners (ACI-001). The task that could have gone one level higher is the one to try first.

Verification: The attendee has a line for each of the four levels, can state their ceiling, and has named one task from this week to try one level higher.

Exercise 3: The Same Kind of Task, Two Ways (30 minutes)

Objective: Do two similar tasks, one assistively and one agentically, and name what changed about your own role.

Instructions:

  1. Choose two similar small tasks in your project, eg two functions to add, two to refactor, or tests for two untested modules.
  2. Do the first one assistively. Use ghost text in an assistive tool, or ask Claude Code only for suggestions and explanations, one step at a time, and make every edit yourself. Note roughly how long it took and what you did by hand.
  3. Commit the first task, so that git status --short prints nothing. Then do the second one agentically: in a fresh Claude Code session, describe the outcome you want and how you will check it, and let the agent plan and carry out the whole task. Answer its questions and permission prompts, but do not break the task into single steps for it.
  4. When the agent reports done, check the work rather than the report: read git diff and run the tests.
  5. Compare the two attempts: what the agent did that you did not ask for, where you had to step in, and what your own job was in each.

Facilitator notes: Push attendees to judge the agentic attempt by its diff and its tests, not by its closing report (ACI-001). An attendee who approves every step, or rewrites the task as single-step instructions, is running an agentic tool with an assistive mental model, which is the page's Micromanager. Bring the discussion to the change of role, from typing the code to defining the task and checking the result. The exercise lets everyone try both ends of the spectrum on a small task. It does not make the agentic end everyone's next step: from the assistive end, that step is conversational.

Verification: The attendee has checked the agentic attempt's diff and tests, and can name one concrete difference between the two attempts in what they did themselves.

Exercise 4: A Count With Its Ref, Its Date and Its Convention (15 minutes)

Objective: Write a count of your project's work so that someone else could reproduce it, and then ask what the work was for.

Instructions:

  1. In your project's directory, count the commits with git rev-list --count HEAD, and read the commit and the date the count was taken at with git log -1 --format='%h %cs'.
  2. Write the count as one line with its ref, its date and its convention, eg "<count> commits at <sha> (<date>), by git rev-list --count, merges included".
  3. Count again with git rev-list --count --no-merges HEAD. If the two numbers differ, note which convention your line uses, and why the line has to say so.
  4. If the way you worked changed partway through the history, eg a new tool, a second agent or a different program in the same repository, mark the commit where it changed. A count or a rate that spans that commit compares two kinds of work.
  5. List your last ten commits with git log -10 --format='%h %cs %s', and beside each write the user problem it solved, or "none named".

Facilitator notes: A count without its ref, its date and its counting convention cannot be reproduced, reconciled or refreshed, and even with all three a commit count describes activity, not productivity (ACI-005). Push for all three on every number. The last step looks for the generation trap's signal: feeling productive while unable to name the user problem a week's work solved (ACI-006). Where an attendee writes "none named", ask what the commit was for.

Verification: The attendee has a count written with its commit, its date and its counting convention, and a list of their last ten commits, each marked with the user problem it solved or "none named".

Stretch Goals

  • Take a figure about AI productivity that you have seen quoted, eg a multiplier or a percentage, and find its source, its date and how it was counted. If you cannot find all three, write it down labelled as an estimate.
  • Preview the course's evaluation framework. Give your current setup a first score from 1 to 5, where 1 is the least and 5 the most, on each of its six single-agent dimensions: autonomy level, context engineering support, session continuity, verification and review, team and enterprise readiness, and methodology ecosystem. Add one sentence of evidence for each. The framework is course design rather than a finding. Keep the scores: 104 scores the six dimensions at the end of the first year, and 301 adds the seventh, multi-agent coordination.
  • If you have a second AI coding tool, repeat Exercise 3 with it and compare what each tool did unasked.