What Claude Code Is (and Isn't)

A lot of tools call themselves "AI coding agents" when what they really are is a chatbot with a file-reading library and a code-completion model. Claude Code is in a different category -- it's an autonomous agent that reads your entire codebase, writes and edits files across multiple directories, runs shell commands, spawns subagents to work in parallel, and manages git. This lesson places it in the ecosystem so you know what you're working with before you install anything.

What you'll learn

• Claude Code is not a code-completion plugin or an IDE sidebar -- it's a terminal-based agent with full filesystem access, shell execution, and git integration
• It runs in two modes: print mode for fire-and-forget scriptable tasks, and interactive mode for multi-turn conversations with tool-use approval
• Subagents are first-class: Claude Code can spawn child agents with restricted tool sets to work on separate tasks in parallel
• The CLAUDE.md memory system means Claude walks into your project already knowing the build system, conventions, and rules -- no re-explaining every session

The problem: "coding agent" means too many things

Most tools marketed as coding agents are really just autocomplete with extra steps. GitHub Copilot suggests the next line. Cursor fills in a function body. These are code completion tools, not agents. They don't run commands, they don't modify files across directories, and they don't coordinate work across multiple parallel processes.

Claude Code is a different category. It's a terminal-based agent that operates on your entire codebase. When you give it a task -- "add rate limiting to the API endpoints, write tests, and update the docs" -- it reads the relevant files, plans the changes, writes the code, runs the tests, fixes failures, and reports what it did. It doesn't suggest code. It ships code.

Options: where Claude Code sits in the ecosystem

Tool	What it is	Claude Code vs. it
GitHub Copilot	IDE code completion	Suggests the next line or function. Claude Code reads the whole repo, writes files, runs tests, and manages git
Cursor	AI-augmented IDE with inline editing	An IDE with an AI chat panel. Claude Code is the terminal agent -- it works outside any IDE, and you can use it from scripts, CI/CD, or cron
Codex CLI (OpenAI)	Terminal-based coding agent	Similar category. Claude Code's differentiators are subagents that run in parallel, the CLAUDE.md memory system, and Anthropic's Claude model family
OpenCode CLI	Terminal-based coding agent	Similar to Codex. Claude Code has built-in subagent orchestration and a deeper permissions model
ChatGPT / Claude.ai	Browser-based chatbot with no system access	Claude Code has full terminal access: it reads and writes files, runs shell commands, and manages git. It's not limited to a chat window

Claude Code's architecture -- the parts that matter

Claude Code runs as a terminal process. Under the hood, it's a tool-calling loop:

1. You give it a task (in print mode or interactive mode)
2. Claude reads the relevant files in your codebase
3. Claude decides what to do: write a file, run a command, search the codebase, spawn a subagent
4. Each tool call returns output that Claude processes
5. Claude decides the next step -- more tool calls, or a final response
6. The loop continues until the task is complete or the turn budget is exhausted

The loop is the same whether you're running claude -p "fix this bug" in print mode or chatting interactively. The difference is what happens between steps: print mode runs autonomously until done, interactive mode pauses for your input.

What this course assumes

You should be comfortable in a terminal, know how to use git, and have a basic understanding of what an AI agent does. If the idea of a tool-calling loop is new to you, start with the flagship course's What Makes an Agent lesson first -- this course builds on that foundation and gets moving fast.

This course covers Claude Code as it exists in v2.x. Every command, flag, and feature described here is verified against the current Claude Code documentation. Nothing is invented. If a feature changes after this is published, the official Claude Code docs are the authoritative reference.

Build it: confirm your mental model

Since this is a conceptual lesson before installation, the "build" is verifying you understand the architecture. Open the Claude Code documentation and confirm:

# Open the docs in a browser (or read them with curl):
curl -s https://docs.anthropic.com/en/docs/claude-code/overview | head -80

Look for these three things in the docs:

1. The two modes Claude Code runs in (print and interactive)
2. The tool-calling loop description
3. The subagent system

If you can find all three, you have the right mental model for what you're about to install.

What goes wrong

Mistake	How you notice it	The fix
Assuming Claude Code is "Copilot but in the terminal"	You try to use it for inline code completion and get frustrated when it writes whole files	Claude Code is an agent, not a completion tool. Give it tasks, not line-by-line prompts. "Add error handling to all API routes" not "complete this function"
Expecting Claude Code to work without filesystem access	It can't read files or run commands and errors out	Claude Code needs read/write access to the project directory. It won't work in a sandboxed environment without explicit tool permissions
Confusing print mode with interactive mode	You use claude -p and expect it to ask follow-up questions	Print mode is fire-and-forget. It runs the task and exits. Use interactive mode (claude) when you want a conversation
Thinking subagents are just parallel threads	You spawn subagents and they step on each other's files	Subagents are independent Claude processes with their own tool access. They don't share state. Design tasks so subagents work on non-overlapping files

Confirm it worked

This is a conceptual lesson -- the confirmation is being able to answer these questions before moving on:

1. What is the mechanical difference between Claude Code and an IDE code-completion tool?
2. What are the two modes Claude Code runs in, and when would you use each?
3. What happens in the tool-calling loop after Claude makes a tool call?

If the answers are (1) Claude Code is an autonomous agent that reads, writes, runs commands, and manages git -- not a line-by-line completion tool, (2) print mode for scriptable one-shot tasks, interactive mode for multi-turn conversations, and (3) it processes the tool output and decides the next step -- you're ready for installation.

Next: Installation & Authentication -- getting Claude Code running on your machine.