What Claude Code Is (and Isn't)

Before any commands or config, fix one idea in your head, because everything else in this course rests on it: Claude Code is an agent, not an autocomplete.

An autocomplete tool watches your cursor and offers the next line. You are still doing the work — reading the codebase, deciding what to change, opening files, running tests, fixing the failures. The tool just types a little faster than you.

Claude Code works the way a capable teammate does. You hand it a goal in plain language — "add rate limiting to the login endpoint and update the tests" — and it reads the relevant parts of your codebase, forms a plan, edits multiple files, runs the tests, reads the failures, fixes them, and commits the result. It is doing the loop you would otherwise do by hand, not just predicting your next keystroke.

That shift — from suggesting lines to executing tasks — is the whole reason the tool exists, and it's why the skills you'll learn here (steering it, scoping work, reviewing diffs, managing context) look more like delegating to a junior engineer than configuring an editor plugin.

The clearest way to internalize the model is to put the two side by side. Tools like GitHub Copilot's classic inline suggestions are completion tools: they predict the next token at your cursor, in the file you're already in, while you drive. They're genuinely useful — but the human stays in the loop for every decision.

Claude Code is an agentic tool. It operates across your whole project, takes a sequence of actions on its own, and closes its own loop by running checks. Two properties make that safe rather than reckless:

• It asks permission. It cannot silently edit files or run shell commands. By default it pauses and asks before edits and commands (you can widen or narrow that — covered later in the course).
• It stays steerable. You're never locked out mid-run. Press Esc to interrupt instantly, type a correction, and it picks up your new instruction after its current action. You never have to restart from scratch.

Neither is "better" in the abstract — they solve different problems. But conflating them is the single most common reason newcomers misuse Claude Code, so keep the distinction sharp.

What does "agentic" actually do under the hood? Every Claude Code task runs the same loop — three blended phases that repeat until the work is done:

1. Gather context — read files, search the code, explore the project to understand what's there.
2. Take action — edit files, run commands, create branches, run a dev server.
3. Verify results — run tests, check output, evaluate whether the goal is actually met — and if not, loop back.

The loop is adaptive, not a rigid script. A question like "where is auth handled?" may only need phase 1 — gather context, answer, done. A refactor across ten files runs all three phases several times, re-reading after each edit and re-running tests until they pass. Claude decides how much of the loop a given task needs.

This is exactly why a verifier matters so much: the Verify phase is what lets the agent know it's actually finished, rather than stopping when the code merely looks done. Give it a test command or a build and it closes its own loop; withhold one and you become the verification step.

      ┌─────────────────┐
      │ Gather context  │  read files, search, explore
      └────────┬────────┘
               ▼
      ┌─────────────────┐
      │  Take action    │  edit, run commands, branch
      └────────┬────────┘
               ▼
      ┌─────────────────┐
      │ Verify results  │  run tests, check output ──┐
      └─────────────────┘                            │
               ▲   (not done yet — loop back)         │
               └─────────────────────────────────────┘

An agent is only as capable as the actions it can take. Out of the box, Claude Code ships with five categories of built-in tools — the verbs it uses to move through that loop:

You don't invoke these by hand — Claude selects them as the task demands. The thing to notice is the shape of the capability: it can not only read and write code but run it and search the web, which is precisely what separates an agent from a suggestion box. (Beyond these built-ins, MCP servers let you add external tools — databases, Jira, Figma — but that's a later lesson.)

Here's the part that surprises people: Claude Code is not a terminal program with some spin-off apps. It's one engine that shows up on many surfaces. You'll most often meet it as a terminal command, but the same agent runs everywhere:

Because it's one engine, your configuration is portable. The CLAUDE.md instructions you write, your settings, and your MCP server connections work identically across every surface. Set up your project once in the terminal, and the web session, the IDE extension, and the CI run all behave the same way. You learn the tool once; you use it everywhere.

This is also why this course teaches concepts (the loop, permissions, context, CLAUDE.md) rather than one app's buttons — the concepts transfer across every surface unchanged.

The agent is powered by Anthropic's frontier models. Specifics shift as new models ship, so run /model to see what your account offers right now:

• Default model depends on your account tier: Pro, Team Standard, and Enterprise subscription seats default to Sonnet 4.6; Max, Team Premium, Enterprise pay-as-you-go, and Console (API) default to Opus 4.8. Either way, switch with /model or the --model flag (e.g. claude --model opus) — run /model to see the options for your account.
• Opus and Sonnet both serve well; reach for Opus on the hardest reasoning, planning, and refactoring tasks and Sonnet for fast everyday coding.
• Context window: 200K tokens standard, automatically extended to 1M for Opus on Max, Team, and Enterprise plans with no extra setup. Sonnet with 1M context requires usage credits. Switch within a session via /model opus[1m] or /model sonnet[1m]. That's room to hold large portions of a real codebase, the conversation, your CLAUDE.md, and tool results at once — which is what lets the agent reason across many files instead of one snippet.

A practical note for newcomers, because it trips people up: Claude Code is not on the free tier. It requires a paid plan — Pro, Max, Team Premium, Enterprise, or Console (API). A free Claude.ai account cannot run it.

One more currency note worth fixing now. The older tiered "think" / "think hard" escalation is gone — those phrases are now passed through as ordinary prompt text, because models from 4.6 onward use adaptive thinking and decide how much to reason based on the task automatically. The one keyword that still works is ultrathink: include it anywhere in a prompt to request deeper reasoning on that turn without changing your session effort setting.

An agent that can run git, edit files, and execute shell commands sounds alarming — until you see the two guardrails that make it trustworthy. They're worth understanding on day one.

1. It asks permission before acting. Claude Code does not silently change your files or run commands. By default it pauses and asks before file edits and before running commands, showing you exactly what it wants to do. You stay in control of every consequential action. (You can tune this — granting standing permission for safe operations or locking things down for automation — which the permissions lesson covers in depth.)

2. Every edit is reversible via checkpoints. Before Claude edits a file, it snapshots the prior state. If a change goes wrong, press Esc Esc (on an empty prompt) or run /rewind to restore your code — and optionally the conversation — to an earlier checkpoint. Every prompt you send also creates a checkpoint, so you can rewind to any point in the session.

Two honest limits on checkpoints, so you don't over-trust them:

• They are local to the session and separate from git — think of them as an undo stack for the agent's edits, not a replacement for commits.
• They cover file changes only. Side effects outside the filesystem — a dropped database row, a sent API request, a git push — are not captured by a checkpoint and can't be rewound.

Together, permission to act and power to undo are what let you delegate real work to an agent without flying blind: nothing happens without your say-so, and almost any local mistake is one keystroke from being unmade.