An agent that codes in your terminal, with access to your files, git and your commands. It's not autocomplete: it's a colleague that reads the repo, proposes a plan, edits, and runs the tests. Here's the mental model and the reflexes that matter.
Claude Code is a command-line agent. You talk to it in natural language, and it acts on your project: it reads files, writes them, runs commands, makes commits. The difference from a chat is access: it works on your real code, not on a copy-paste.
It's the same shift in posture as for application agents: from “generate an answer” to “carry out a task.” I talk about it in from a prompt to agentic.
One-command install, then start the session from the project root — this matters: Claude takes the current directory as its working scope.
A Claude Code session needs Anthropic API access (or a compatible subscription). Run it in a git repo: you can review and revert its changes like any commit.
The core rhythm: you describe an intent, Claude explores, proposes a plan, then edits — showing you each diff before applying. You stay in the loop: accept, reject, or redirect.
If you remember one thing: write a CLAUDE.md. It's a Markdown file at the root, read automatically at the start of every session, that serves as the project's long-term memory. Without it, you re-explain your stack and conventions every time — and the agent guesses the rest, often badly.
What makes a good CLAUDE.md isn't length, it's density: the non-obvious decisions, the project's traps, the exact commands. Every line saves you a repeated correction.
Treat it like code: version it, review it as a team, grow it the moment you catch yourself repeating an instruction to the agent. A living CLAUDE.md means an agent that knows your project instead of guessing it.
It layers: a global CLAUDE.md (~/.claude/CLAUDE.md) for your personal preferences, one per repo for the project, and even one per subfolder for a specific module.
A skill is a procedure you teach once and Claude reuses on its own. Concretely: a folder with a SKILL.md file describing a know-how (deploy, review a PR, generate a report) and, if needed, scripts. Claude reads the description and triggers the skill when the task matches.
The SKILL.md is a header (name + description — that's what Claude reads to decide) plus steps. The description is the critical part: state clearly when to use it.
The difference from CLAUDE.md: CLAUDE.md is always loaded (the permanent context), a skill is loaded only when relevant. You put one-off procedures in skills to keep the context light.
Once the basics are in place, Claude Code unlocks capabilities that take it from assistant to team. Three that genuinely change the game:
Claude delegates isolated tasks to parallel agents, each with its own context. Useful to parallelize, or to have a “verifier” agent review another’s work.
The Model Context Protocol plugs in external tools: GitLab, Sentry, a database, your own service. The agent then acts well beyond files.
Reusable prompts, versioned in .claude/commands. /review, /ship: your workflows become a command, shared with the team.
Scripts triggered automatically at key moments (before a commit, after an edit): lint, formatting, guardrails — without thinking about it.
Subagents and MCP are the very same ideas as on the product side: give tools and make several agents collaborate. I dig into them in give an agent tools.
One feature per loop. An agent set loose on “redo the whole app” drifts; on a scoped task, it’s surgical.
Commit often. A change that goes sideways reverts in one command — you’re never afraid to let it try.
Ask it to run tests and the build. An agent that reads its own error output fixes itself.
Diffs pass before your eyes. For destructive actions, keep control — it’s human-in-the-loop.
Don't let it run without review, especially on commands that delete or deploy. Same principle as on the product side: human-in-the-loop, for real.
Claude Code isn't magic: it's a fast colleague that needs a frame. The core is the CLAUDE.md — the project's memory. Then skills capitalize your know-how, and superpowers (subagents, MCP, commands) turn it into a team. Small loops, frequent commits, reviewed diffs: that's what takes it from gadget to multiplier.
Claude Code docs ↗