什么是 Claude Code

Claude Code is an agentic coding tool that lives in your terminal and IDE. Instead of copy-pasting snippets into a chat window, you let Claude read your real files, run commands, and edit code directly in your project.

It is not just an autocomplete. It runs an agentic loop: it inspects the task, calls tools, reads the results, and keeps going until the work is genuinely done.

On the Claude Certified Architect exam, this lives in Domain 3 (Claude Code Config & Workflows, 20% of the exam). Understanding what Claude Code is — and how it differs from a plain chatbot — is the foundation for everything else in this track.

A plain LLM chat call is one round trip: you send a message, you get text back. Claude Code is different — it is built on the agentic loop:

• Send a request to the model.
• Inspect the stop_reason on the response.
• If it is tool_use, run the requested tool and append the result to the conversation history.
• Repeat until the model returns end_turn.

The critical rule: you terminate on the stop reason, never by scanning the model's text for words like "done" or "finished". Parsing text for completion signals is a classic anti-pattern the exam loves to test.

Claude Code's power comes from a small, focused set of built-in tools. As an architect you should know each one cold:

• Glob — find files by pattern, e.g. **/*.test.tsx.
• Grep — search file contents with a regex.
• Read — load a file into context.
• Write — create a new file.
• Edit — make a precise, unique-match change to an existing file.
• Bash — run shell commands.

These are deliberately few. Four to five well-scoped tools per agent is optimal; piling on 18+ tools degrades the model's ability to pick the right one.

The reason a terminal agent beats a chatbot for real codebases is incremental investigation. Claude Code does not read your whole repo at once. It works the way a senior engineer does:

• Grep for entry points or a symbol.
• Read the files that matched.
• Grep again for usages of what it found.
• Read the consumers.

Each step narrows the search and pulls only the relevant code into context. This keeps the context window lean and the reasoning sharp — far better than dumping an entire directory into a single prompt.

The Edit tool performs a precise string replacement, and it requires the matched text to be unique in the file. This is a safety feature: a unique match means the change lands exactly where intended.

If the match is not unique — or the surrounding code is too ambiguous to target — the correct fallback is to Read the file and then Write it back with the change. As an architect, recognize that Edit failures are usually a uniqueness problem, not a tool bug.

"Lives in your terminal and IDE" is not marketing — it is the operating model. Because Claude Code runs inside your project, it has direct access to:

• Your actual file tree (via Glob, Grep, Read).
• Your shell (via Bash) — so it can run tests, linters, git, and build commands.
• Your project configuration files, which steer its behavior.

This is what makes it agentic rather than advisory. A chatbot can suggest a fix; Claude Code can apply the fix, run the test suite to confirm it, and iterate if the test fails — all without you leaving the terminal.

You steer Claude Code with a CLAUDE.md file — persistent instructions it reads at the start of a session. There is a hierarchy:

• User-level (~/.claude/CLAUDE.md) — personal, not shared via version control. New teammates never see it.
• Project-level (./CLAUDE.md or .claude/CLAUDE.md) — shared via VCS, so the whole team gets the same guidance.
• Directory-level — scoped to a subtree.

Use @path imports to modularize, e.g. @./standards/coding-style.md. The exam distinction to remember: project-level is shared; user-level is private.

Beyond CLAUDE.md, Claude Code offers finer-grained configuration:

• .claude/rules/ — files with YAML frontmatter paths: that load only when you edit matching files. This saves context and tokens versus stuffing everything into one monolithic CLAUDE.md.
• .claude/skills/ — the current way to package reusable workflows (.claude/commands/ is the legacy form). Project-scoped skills are shared via VCS; user-scoped ones are personal.

Skill frontmatter can set context: fork to isolate verbose output, restrict allowed-tools, and give an argument-hint.

Claude Code can either jump straight to editing or first propose a plan for your approval. Knowing when to use which is an architect-grade judgment call:

• Use Plan Mode for large changes, when there are multiple viable approaches, for architectural decisions, or when you want safe exploration and explicit approval before any edits land.
• Use direct execution for single-file fixes or a clear stack trace where the fix is obvious.

For the discovery phase of a large task, an Explore subagent isolates the investigation output so it does not clutter the main context.

Claude Code is not just interactive — it runs in pipelines too. The flags that matter:

• -p / --print — non-interactive mode, required in any CI pipeline.
• --output-format json (optionally with a schema) — produces parseable results your pipeline can act on.

A key reliability practice: run automated code review in an isolated session, separate from the one that generated the code. A fresh reviewer is less biased by the generation context — the author retains its own reasoning and tends not to challenge itself. When re-running, include the prior results and report only new or still-unfixed issues to minimize false positives.

Two built-in commands shape how Claude Code manages state across a long session:

• /memory — edits CLAUDE.md so your instructions persist across sessions.
• /compact — compresses the current context when it grows large. Useful, but with a known risk: compression makes numbers, percentages, and dates vague. Keep critical transactional facts somewhere verbatim rather than trusting a compacted summary.

This connects to Domain 5 (Context Management & Reliability): models attend most to the start and end of context ("lost-in-the-middle"), so where you place key facts matters.

A scenario from the Code Generation domain. Test your understanding of the agentic loop.

Key takeaways from this lesson:

• Claude Code is an agentic coding tool in your terminal and IDE — it reads real files, runs commands, and edits code directly.
• It runs an agentic loop driven by stop_reason; terminate on end_turn, never by parsing text.
• Its built-in tools — Glob, Grep, Read, Write, Edit, Bash — support incremental investigation; Edit needs a unique match, falling back to Read+Write.
• CLAUDE.md steers it: project-level is shared via VCS, user-level is personal; .claude/rules/ and .claude/skills/ add scoped, on-demand configuration.
• Plan Mode suits big or ambiguous changes; direct execution suits clear single-file fixes.
• In CI/CD, use -p and --output-format json, and review in an isolated session.

You now have the foundation for the rest of the Claude Code Fundamentals track.