Claude Code: the CLI for agentic engineering

Claude Code is what Anthropic thinks agentic engineering should look like — a CLI, not an IDE. If your work is mostly in the terminal, it's a force multiplier.

What it actually is

A terminal-native coding assistant. You describe a task; it reads your repo, makes changes, runs tests, iterates. Can operate autonomously (within boundaries you configure).

Fundamentally different shape than Cursor: Cursor helps you edit; Claude Code delegates the edit.

The interaction model

$ claude
> Implement the TODO in src/auth/callback.ts — it needs to handle
  the error case when the OAuth state doesn't match.

[Claude Code analyzes the file, writes the change,
 runs the test file, reports results]

> Looks good. Commit the change with a concise message.

[Claude Code stages the file and commits]

You're managing the engineer, not doing the typing.

The core primitives

• Slash commands. /commit, /test, /plan — pre-defined workflows.
• Hooks. Code runs at specific events (e.g., after every file write, before a tool call). Used for linting, formatting, custom validation.
• Subagents. Custom personas with their own system prompts — e.g., a "code reviewer" subagent vs. a "test writer" subagent.
• MCP servers. Connect external tools (your APIs, your databases, your observability).

You can compose all of these to match your team's workflow.

Day-one productivity patterns

• Use it for tedious multi-file work. "Rename this symbol everywhere and update its tests." Fast.
• Use it for exploration. "What does this service do? Read the code and explain."
• Use it for maintenance. "Upgrade this dependency. Fix any type errors the upgrade introduces."

Where it shines: tasks that a human engineer finds boring but error-prone. Where it struggles: tasks requiring deep intuition about the specific codebase's idiosyncrasies that aren't written down anywhere.

Hooks are the team-sharing unit

Teams customize Claude Code by committing hooks to the repo:

• PostEdit hook that runs formatters, linters.
• PreTool hook that blocks destructive commands unless explicitly confirmed.
• Stop hook that validates all tests pass before Claude Code declares done.

Hooks make the tool match your team's discipline, automatically, even for new hires.

Safety model

Out of the box, Claude Code asks before destructive operations. Configure based on your risk tolerance:

• Strict mode: everything gets confirmation.
• Normal mode: most things auto; dangerous ones prompt.
• YOLO mode: you trust it fully (use with extreme caution; easier in a sandboxed environment).

Teams that ship cleanly usually stay near Normal.

MCP: extending Claude Code

Your team's operational knowledge can be exposed as MCP tools:

• runbook_check(service) — reads your internal runbooks.
• deploy_status(environment) — talks to your deploy system.
• get_recent_errors(service) — pulls from your observability.

Claude Code gains operational context. Now it can "look at recent errors in the payments service and suggest a fix" without leaving the terminal.

Where it's not the right tool

• Heavy UI work. Running a dev server, tweaking CSS by eye, iterating on interactions — IDE wins.
• One-line edits. Faster to just type it.
• Teams that distrust autonomous changes. Fits an engineering culture comfortable with AI doing real work; rough fit in cultures that aren't.

The meta pattern

Claude Code is most valuable when you treat it as a new team member:

• Write documentation for it (CLAUDE.md files in your repo explain project conventions).
• Onboard it with hooks that encode your team practices.
• Give it access to the same tools a human engineer uses.

This is different from how most people adopt AI tools. It's also where the biggest productivity gains come from.