AI coding tools

The previous lesson established the mental model: you are now a director, not an implementer. Before you start directing anything, you need to know your tools — what they can see, what they can do, and what their limits are. Using the wrong tool for a task is one of the most common sources of frustration in agentic coding.

The three dimensions that matter

When comparing AI coding tools, three dimensions explain almost all meaningful differences:

Codebase access. Can the tool read your actual project files, or is it working only from what you paste into a chat window? An agent that can't read your files is a powerful autocomplete at best. One that can index your entire repository operates with a fundamentally different kind of awareness.

Command execution. Can the tool run shell commands — your test suite, your linter, your build script — and read the output? A tool that can run pytest and see which tests fail can iterate on its own work. One that can't requires you to copy-paste output back into the chat, re-entering the manual loop you were trying to escape.

Session memory. Does the tool remember anything across sessions, or does each conversation start from a blank slate? Most current tools start fresh each time. The ones that don't use persistent memory files (you'll learn to write those in the next lesson).

The landscape

Claude Code is a terminal-based agent from Anthropic. It runs in your shell, reads your entire project directory, executes commands, and operates in the perceive-plan-act-observe loop described in the previous lesson. It is the primary tool taught in this course because it is the most capable at multi-file, multi-step tasks, and because the terminal is the universal substrate — every language, every framework, every operating system has a terminal.

Cursor is a code editor (forked from VS Code) with deep AI integration. Its "Composer" / "Agent" mode is a genuine agentic tool: it can read your codebase, propose changes across many files, and apply them. Its advantage over a terminal agent is that you see the diffs inline before applying them. Its limitation is that you are tied to one editor.

GitHub Copilot exists in two modes that are very different. The inline mode (the original) suggests the next line or block as you type — pattern completion, not agentic. The workspace mode can index a repository, answer questions about it, and propose multi-file changes. For developers already living in VS Code, it is a reasonable starting point; for complex agentic tasks it is less capable than Claude Code or Cursor's agent mode.

ChatGPT / Claude (web) are conversational. They have no access to your file system unless you paste code in, and they cannot run commands. Their strength is explanation, architecture discussion, and debugging when you supply the relevant context. They are also useful when you want a second opinion without giving a tool write access to your project.

When to use which

The heuristic is simple: if the task requires touching more than one file or running a command, reach for an agentic tool. If it is a single-file question or a conceptual discussion, a conversational tool is faster and lower risk.

Practical setup for Claude Code

Claude Code is installed as an npm package:

npm install -g @anthropic/claude-code

Once installed, navigate to your project directory and run:

claude

Claude Code will read the files in the current directory (and subdirectories) and enter an interactive session. Type your goal in plain English and it will plan its approach, propose tool calls, and execute them — pausing to ask when it is uncertain or when a step requires explicit confirmation.

A few things to check in your first session:

1. Run git status before and after an agent task so you have a clear diff of what changed. This is the single most important habit in agentic coding.
2. Make sure your test suite (if you have one) runs cleanly before you hand work to the agent. A clean baseline makes the agent's work reviewable.
3. Commit before a large agent task, even a simple git commit -m "before agent run". It costs thirty seconds and saves real pain if the task goes sideways.

What the tool can't fix

No tool changes the fact that you are responsible for the output. A coding tool that can write files and run commands can also break things silently. The next three lessons build the practices that make agentic coding safe and effective: memory files, directing technique, and reviewing the diff.

Where to go next

You know what the tools are and how to launch them. But an agent that starts every session with no knowledge of your project will waste time re-discovering context you have already established. The next lesson teaches you to give agents persistent memory through memory files.