title: "Exercises — Your First Hour" last_updated: 2026-03-21 status: proven difficulty: beginner prerequisites: [00-what-is-agentic-dev]

Exercises: Your First Hour

These exercises use your real project, not a toy example. Each one builds on the previous, so complete them in order. Budget about 45 minutes total.

Exercise 1: The Guided Tour

Objective: Evaluate how well the agent understands your codebase without any configuration, and calibrate your expectations for its reasoning about unfamiliar code.

Steps

  1. Open a terminal and navigate to a project you actively work on.

  2. Start a session with your chosen tool (claude or codex).

  3. Enter this prompt:

    Read this project and give me a high-level summary. What is it, how is it
organized, and what are the key architectural decisions?

  4. Read the agent's response carefully. Note where it is accurate and where it is off.

  5. Now ask a follow-up:

    What are the 3 most important files in this project? For each one,
explain why it matters.

  6. Write down the agent's answer. Then write down your own answer — the 3 files you consider most important.

  7. Compare the two lists. Where do they agree? Where do they differ?

Expected Outcome

The agent should produce a broadly accurate summary but may miss domain-specific nuances, undocumented conventions, or non-obvious architectural decisions. Its "top 3 files" list will likely overlap with yours on 1-2 files but diverge on at least one.

The divergences are the most valuable part. Each one represents context that the agent is missing — context you may want to put in your configuration file later.

Hints

  • If your project is very large, scope the question to a specific directory or module. An agent trying to summarize a monorepo with 500 files will produce a shallow summary. Narrowing the scope gets you deeper, more evaluable output.
  • If the agent's summary is wildly inaccurate, that itself is a useful signal. Ask it: "What files did you look at to reach that conclusion?" This reveals its reasoning path and helps you understand the failure mode.
  • Do not correct the agent during this exercise. You are assessing its unguided performance. Corrections come later.

Exercise 2: Your First Real Task

Objective: Complete a genuine task from your backlog using the agent, measure the time it takes, and rigorously review the output.

Steps

  1. Before starting the agent, pick a small task from your actual work. Good candidates:

    • A unit test that should exist but doesn't
    • A small bug you have been meaning to fix
    • A function that needs documentation or type annotations
    • A simple utility or helper that is on your to-do list

  2. Write the task down in one sentence before you start the agent. This is your "spec."

  3. Start a session and give the agent your task. For example:

    Write a unit test for the `parseConfig` function in src/config/parser.ts.
It should test: valid input returns expected output, empty input throws
an error, and malformed input is handled gracefully.

  4. Start a timer when you press Enter.

  5. Work with the agent until the task is done. If the agent asks questions, answer them. If it proposes incorrect changes, tell it what is wrong and let it try again.

  6. Stop the timer when you consider the task complete.

  7. Run git diff and review every line of the change.

Expected Outcome

A working, committed change that accomplishes your task. Your review should confirm that the code is correct, matches your project's style, and stays within the scope you defined.

Typical timing for a first task: 10-20 minutes including review. If it takes longer than 30 minutes, the task was likely too complex for a first attempt. Note this and choose something smaller next time.

Hints

  • Be specific in your initial prompt. "Write a test" is too vague. "Write a unit test for function X in file Y covering cases A, B, and C" gives the agent clear constraints.
  • If the agent produces something close but not quite right, resist the urge to fix it yourself. Instead, describe what is wrong and let the agent iterate. Learning to give effective feedback is a core agentic development skill.
  • If the agent gets stuck in a loop — producing the same wrong answer repeatedly — that is a signal to step in. Give it more context, rephrase the problem, or point it to a specific file or pattern it should follow.
  • Record your total time. You will use this as a baseline to measure improvement in later modules.

Exercise 3: The Minimal CLAUDE.md

Objective: Create a minimal project configuration file and measure whether it improves the agent's output quality on a task you have already completed.

Steps

  1. Create a configuration file in your project root. Use CLAUDE.md for Claude Code or AGENTS.md for Codex CLI.

  2. Write exactly 5 lines of content (not counting the heading). Use this template:

    # CLAUDE.md

[Project name] is a [one-sentence description].
Built with [primary language] and [primary framework/library].
Run tests with: `[your test command]`
Run the dev server with: `[your dev command]`
[One convention, e.g., "Always use descriptive variable names and add docstrings to public functions."]

  3. Save the file.

  4. Start a new session (so the agent picks up the configuration file).

  5. Run the exact same task you completed in Exercise 2. Use the same prompt, word for word.

  6. Compare the output to your Exercise 2 result:

    • Did the agent follow your stated conventions?
    • Did it use the correct test command or build command?
    • Did the code style match your project better than before?
    • Was there any other noticeable difference in quality?

  7. Write down your observations in 3-4 bullet points.

Expected Outcome

You should notice at least one concrete improvement. Common improvements include: the agent uses the correct testing framework without being told, it follows your naming conventions more consistently, or it structures code in a way that better matches your project's patterns.

Some tasks will show dramatic improvement. Others will show only marginal difference. Both outcomes are informative. Tasks that improve a lot tell you what context the agent was missing. Tasks that improve little tell you the agent was already inferring that context from your codebase.

Hints

  • Use exactly 5 lines. The temptation is to write more, but the exercise is specifically designed to measure the impact of minimal configuration. You will add more lines in later modules as you identify specific gaps.
  • Make sure you start a new session after creating the file. If you add the file mid-session, the agent may not read it until the next session (behavior varies by tool).
  • If you do not see any improvement, that is still a useful result. It means either your task was simple enough that configuration did not matter, or the agent was already inferring the right context from your code. Try a different task to see if the pattern holds.
  • Keep your observations from this exercise. You will refer back to them in Module 03 when we cover advanced configuration strategies.

After You Finish

You have now completed the core loop of agentic development: orient, configure, build, review. Everything in the rest of this curriculum builds on this foundation.

Before moving on, make sure you can answer these questions:

  1. How accurate was the agent's first impression of your codebase?
  2. How long did your first real task take, and was the output correct?
  3. Did a minimal configuration file make a measurable difference?

If you have clear answers to all three, you are ready for Module 02.