title: "Exercises — What Is Agentic Development?" last_updated: 2026-03-21 status: proven difficulty: beginner prerequisites: []

Exercises — What Is Agentic Development?

These exercises are designed to build your intuition for agentic development through direct experience. Do them in order — each one builds on the mental model from the previous.

Exercise 1: Install and First Task

Objective

Install an agentic coding tool and observe how it operates on a real project. The goal is not to accomplish something specific — it is to watch the agent work so you understand the agentic loop: plan, act, observe, adjust.

Steps

  1. Choose your tool. Install either Claude Code or Codex CLI (or both, if you want to compare). Follow the installation instructions in the respective tool guide in this module.

  2. Pick a project. Navigate to any codebase you have on your machine. It does not need to be large or complex — a side project, a tutorial you followed, or even a small open source repo you have cloned. The only requirement is that it has more than a handful of files, so the agent has something to explore.

  3. Ask the agent to explain the project. Start the tool and type something like:

    Describe the structure of this project. What are the main components,
what language and frameworks does it use, and how are things organized?

  4. Watch carefully. As the agent works, pay attention to:

    • Which files does it read first? (Look at the tool calls or file access notifications.)
    • Does it read the package.json, Cargo.toml, pyproject.toml, or equivalent first? Or does it start with source files?
    • How many files does it read before it starts answering?
    • Does it search for patterns, or does it navigate the file tree?
    • Does the answer match your understanding of the project?

  5. Write down your observations. Specifically note:

    • The total number of files the agent read.
    • The tools it used (file read, search, bash commands).
    • Anything it got wrong or misunderstood.
    • Anything it noticed that you had forgotten about or did not know.

Expected Outcome

You should have the tool installed and running, and you should have a concrete understanding of how the agent explores a codebase. You will likely notice that the agent reads a surprisingly large number of files and that its exploration strategy is systematic — it starts with high-signal files (manifests, entry points, configuration) and drills into specifics.

Hints

  • If you do not have a project handy, clone a small open source repo. Something like a Express.js starter, a small CLI tool, or a Flask app works well.
  • If the agent's response seems shallow, follow up: "What does the services/ directory contain? Trace through how a request flows from the API layer to the database." This pushes the agent to read deeper.
  • If you are using Codex CLI in suggest mode, you will need to approve file reads. This is actually useful for this exercise because you see every file access explicitly.

Exercise 2: Spot the Difference

Objective

Compare manual work against agentic work on the same type of task. The goal is to calibrate your sense of where agents add value and where they introduce overhead. Not every task benefits from agentic tools, and this exercise helps you find the boundary.

Steps

  1. Pick a small, concrete task. Choose something you can complete manually in 5-15 minutes. Good candidates:

    • Add a .gitignore file appropriate for your project's language and framework.
    • Rename a function or variable across the codebase.
    • Add a new dependency and import it in the relevant file.
    • Add a missing error handler to an existing endpoint.
    • Write a simple unit test for an existing function.

  2. Do it manually first. Complete the task by hand, the way you normally would. Time yourself (roughly — do not stress precision). Note the steps: which files you opened, what you searched for, what you had to look up.

  3. Reset your changes. Use git checkout . or git stash to undo your manual work so the codebase is back to its original state.

  4. Ask the agent to do a similar task. Describe the task in natural language. For example:

    Add a .gitignore file for this project. It's a Node.js project using
TypeScript. Include common entries for node_modules, build output,
editor files, and OS-specific files.

    Time the agent's work as well. Watch its process.

  5. Compare. Evaluate along these dimensions:

    • Speed: Which approach was faster end-to-end? (Include the time to review the agent's work.)
    • Accuracy: Did the agent's result match or exceed your manual result? Were there mistakes?
    • Completeness: Did the agent include things you forgot or did not think of?
    • Effort: How much mental energy did each approach require from you?
    • Surprise factor: Did anything about the agent's approach surprise you — either positively or negatively?

  6. Write a brief comparison (a few sentences for each dimension). Be honest. If the manual approach was better for this task, say so and note why.

Expected Outcome

For simple, well-defined tasks (like adding a .gitignore), the agent will likely be comparable in speed and may be more thorough (including entries you would not have thought of). For tasks requiring project-specific judgment (like renaming a function with semantic implications), you may find the manual approach more precise. The key insight is that the agent's value increases with the mechanical complexity of the task.

Hints

  • Choose a task you actually know how to do. This exercise is about comparison, not about learning something new with the agent's help.
  • If the agent makes a mistake, do not fix it manually. Ask the agent to fix it. Observe how it handles corrections — this is part of the agentic workflow.
  • If you find the manual approach was clearly faster, that is a valid and useful data point. Some tasks are better done manually. The skill is knowing which ones.

Exercise 3: Agentic vs. Non-Agentic

Objective

Build the judgment muscle for choosing the right mode of AI assistance. Given a set of real tasks from your own work, categorize each one by the mode that fits best: completion (autocomplete/copilot), chat (ask a question), or agentic (autonomous multi-step). This is the most important skill in this module — knowing when to reach for which tool.

Steps

  1. List 5 tasks from your recent work. Look at your last week or two of development. Pull out 5 concrete tasks you actually did (or need to do). Write each one as a short description. Examples:

    • "Fixed a typo in an error message."
    • "Added pagination to the /users endpoint."
    • "Investigated why the CI build was failing intermittently."
    • "Refactored the authentication middleware to use the new token format."
    • "Wrote API documentation for the billing endpoints."

  2. For each task, categorize it. Assign it to one of:

    • Completion — best handled by autocomplete/copilot suggestions as you type.
    • Chat — best handled by asking a question and getting an answer or snippet.
    • Agentic — best handled by an autonomous agent that reads, edits, runs, and iterates.

  3. Explain your reasoning. For each task, write 2-3 sentences explaining why you chose that category. Consider:

    • How many files are involved?
    • Is the task well-defined or ambiguous?
    • Does it require running commands to verify?
    • Is there a lot of mechanical work (boilerplate, repetition, cross-file changes)?
    • Does it require deep project context or is it self-contained?

  4. Identify the borderline cases. At least one of your 5 tasks should be a close call — a task where two modes seem roughly equal. Explain what would tip it one way or the other.

  5. Share and discuss. If you are going through this curriculum with others, compare your categorizations. Disagreements are productive — they reveal different mental models about where agents add value.

Expected Outcome

You should have a concrete, personally relevant framework for choosing the right mode of AI assistance. The general pattern that emerges:

  • Completion fits single-line or few-line tasks where you already know what you want to write: finishing a function signature, writing a quick conditional, filling in boilerplate.
  • Chat fits questions and isolated problems: "How do I parse a date in this format?", "What's wrong with this regex?", "Explain this error message."
  • Agentic fits multi-step tasks that touch multiple files and benefit from running commands: adding features, refactoring, writing tests, investigating bugs, making cross-cutting changes.

The borderline cases are the most instructive. A task like "add a simple helper function" might be completion-level if it is one function in one file, chat-level if you are unsure about the approach, or agentic if it requires updating imports and tests across multiple files.

Hints

  • Be specific about the tasks. "Build a feature" is too vague. "Add email validation to the signup form, including error messages and a unit test" is concrete enough to categorize meaningfully.
  • If you find most of your tasks fall into one category, deliberately think of tasks from a different category. The goal is to populate all three buckets so you can see the boundaries.
  • There is no single right answer. Reasonable people will categorize the same task differently based on their familiarity with the codebase, their typing speed, and their comfort with the tools. The value is in the reasoning, not the label.