Claude Code is a coding agent that lives in your terminal. You tell it what you want, it reads your entire project, edits files, runs commands, manages git, and hands you the result. You review. That's it.
It's not a chatbot. It's not autocomplete. It's not an IDE. It's a terminal process that understands your complete codebase — not just the open file — and acts on it.
I use it over twelve hours a day, every day, at a professional software company — a SaaS — where we have hundreds of engineers. Not to experiment. To ship software to production with specs, tests, and real deploys. And I've been doing this for over a year.
Most articles I've read about Claude Code are written by people who don't use it professionally in high-stakes scenarios. And that's fine — but there's a subtle difference between breaking a personal deploy and breaking a pipeline that costs thousands of euros, with real stakeholders, real customers, real money.
This article is written by someone with skin in the game.
What Claude Code is NOT
The first confusion I see in people discovering Claude Code: mixing it up with Claude Desktop or Claude.ai.
Claude.ai is the web interface where you chat with Claude. You can ask it for help with code, but it has no access to your project, doesn't edit files, doesn't run commands.
Claude Desktop is Anthropic's desktop application. It has several tabs: Chat, Cowork, and Code. The Code tab is a graphical interface that runs the same engine as Claude Code — with visual diffs, parallel sessions, app preview, and graphical connectors. For non-developers or people who prefer a GUI, it's an excellent entry point. I have a dedicated tip on Desktop's 5 exclusive features.
Claude Code is the terminal agent. No intermediate layers. You, the model, your file system. It's the source of origin of the artifact that is code. If you already use an editor like Zed or Neovim and live in the terminal, it's the natural choice.
The deeper distinction — autonomous agent vs assisted IDE — I explain in depth in the Claude Code vs Cursor comparison.
What it can do (with real examples)
Practically anything you want. With a good prompt you'll get pretty far. But in the professional world, where I can speak from experience, we use specifications.
When you combine the power of a frontier model like Claude Opus with a solid spec system aligned with project reality, features that used to take weeks get completed in hours while maintaining quality. But it's a continuous process — not magic.
Concrete capabilities:
- Read and understand code — analyzes entire projects, not just individual files
- Edit multiple files — cross-file refactoring with full context
- Run commands — build, test, lint, whatever you need
- Manage git — commits, branches, PRs, conflict resolution, all in natural language
- Write and run tests — generates unit tests and runs them
- Debug — finds and fixes bugs spanning multiple files
- Documentation — generates and updates docs
- Code review — reviews changes and suggests improvements
The key isn't the capability list — any article gives you that. The key is that all of this happens within a spec-driven process where every step is traceable. Frameworks like OpenSpec or methodologies like CRAFT exist precisely for this.
Where it lives: 7 access points
This is something no other article presents completely. Claude Code isn't just "a terminal." It's 7 ways to access the same engine:
| Access point | What it is | Who it's for |
|---|---|---|
| Terminal (CLI) | The primary experience. claude in your terminal |
Terminal-first developers |
| IDE extensions | Native extensions for VS Code and JetBrains | Developers who prefer an IDE |
| ACP (Agent Client Protocol) | Open standard by Zed Industries. Claude Code as a first-class agent in Zed and JetBrains via the ACP Registry | Zed users or ACP-compatible editors |
| Claude Desktop (Code tab) | GUI with visual diffs, parallel sessions, app preview, graphical connectors | PMs, non-terminal profiles, onboarding |
| Web (claude.ai/code) | Persistent cloud sessions | When you don't have your machine |
| GitHub (@claude) | Mention @claude on issues or PRs | Code review and CI automation |
| Mobile | Dispatch, Remote Control, Channels (Telegram, Discord, iMessage) | Launch or monitor tasks from your phone |
ACP deserves special mention: it's like LSP (Language Server Protocol) but for AI agents. Zed created it as an open standard and JetBrains adopted it with their ACP Registry. Claude Code is one of the supported agents. This means you can use Claude Code as a first-class agent in any ACP-compatible editor, without depending on a proprietary extension.
For a deeper look at Desktop's exclusive features, I have a dedicated tip. And for controlling Claude Code from your phone, tips on Remote Control and Channels.
How much it costs (the reality)
The free Claude.ai plan does not include Claude Code. You need a paid plan.
| Plan | Price | Who it's for |
|---|---|---|
| Pro | $20/mo ($17/mo billed annually) | Getting started, moderate use |
| Max 5x | $100/mo | Intensive daily use |
| Max 20x | $200/mo | Professional use without practical limits |
| API (BYOK) | Per token | Full cost control |
| Team | From $25/seat/mo | Teams with centralized billing |
My experience: I use the Max plan. Pricing is transparent — I know what I pay, I know what I get. On Pro I'd sometimes hit the limit. On Max, using a spec-driven methodology like CRAFT that optimizes token usage, I rarely exhaust the quota.
My advice: if you're going to invest in a coding agent, do it with Claude. You're closer to the source — the de facto standard model for coding. That said, there's no bad option. If you prefer an integrated IDE, Cursor is excellent. Try it and decide for yourself.
For a detailed analysis of which model to choose based on your plan, I have a dedicated tip.
Getting started in 5 minutes
1. Install (NPM is deprecated — use the native installers):
# macOS / Linux
curl -fsSL https://claude.ai/install.sh | bash
# Windows (PowerShell)
irm https://claude.ai/install.ps1 | iex
# macOS (Homebrew)
brew install --cask claude-code
2. Navigate to your project and run:
cd /path/to/your/project
claude
3. Authenticate — your browser opens automatically. Sign in with your Anthropic account.
4. Your first prompt:
What does this project do?
Claude will analyze your codebase and give you a summary. From there, ask for whatever you need in natural language.
5. Understand permissions — Shift+Tab to switch between modes:
| Mode | Behavior |
|---|---|
| Default | Claude asks permission before editing files or running commands |
| Auto-accept edits | Edits without asking; still asks for commands |
| Plan mode | Read-only — creates a plan you approve before execution |
This is the first thing that confuses beginners: Claude will ask permission for everything. It's deliberate — it's a safety system. Over time, you can configure granular permissions to automate what you trust.
And the biggest mistake beginners make: not configuring the tool. Spend quality time understanding how it works before rushing to produce. CLAUDE.md, hooks, context — all of these exist so Claude works the way you want, not the other way around. Claude Code has an interactive tutorial that's a great starting point.
The customization ecosystem (bird's eye view)
Claude Code isn't just an agent that responds to prompts. It's an extensible platform with 6 mechanisms:
| Mechanism | What it does | Example |
|---|---|---|
| CLAUDE.md | Persistent instructions Claude reads every session | "Use pnpm, not npm. Follow patterns in /src/composables" |
| Hooks | Deterministic automations that fire on lifecycle events | Format after every edit, block destructive commands |
| Skills | Reusable commands invocable with /slash | /review-component, /deploy, /generate-tip |
| MCP | Connection to external services via open protocol | Notion, Playwright, databases |
| Subagents | Specialized agents with their own context and permissions | Codebase research, parallel tasks |
| Plugins | Packages that bundle skills, hooks, and MCP in one installable | Community marketplace |
You don't need to learn all of this on day one. Start with CLAUDE.md — it's a markdown file with instructions for your project. Everything else will come when you need it.
For a complete view of how these 6 mechanisms relate, I have a dedicated tip.
Who it's for (and who it's not)
Claude Code is for you if:
- You're a developer who wants an agent that understands your complete project
- You're comfortable (or want to become comfortable) in a terminal
- You seek control and predictability, not magic autocomplete
- You work in a professional environment where quality matters
Claude Code is probably not for you if:
- You want a drag-and-drop or visual experience
- You're not willing to invest time in configuration
- You want AI to write everything without supervision
If your profile is more visual and you prefer a complete IDE, Cursor is the best alternative I know. If you're terminal-native but want to explore options, ACP lets you try Claude Code inside Zed or other compatible editors.
Closing
Claude Code is more than a tool. It has the potential to change your professional life for the better. But you need curiosity and willingness to learn.
Don't try to master it — it changes every day. The tool I describe today will be different tomorrow. The model changes, the features change, the ecosystem changes. Make your peace with that and enjoy the process.
My biggest mistake was trying to prompt my way to productivity instead of investing time in a solid methodology. When I adopted Spec Driven Development — first with OpenSpec, then with my own methodology CRAFT — everything changed. I stopped improvising and started building with traceability.
And one last piece of advice: don't chase gurus. Go to the official documentation — it's spectacular. Keep it open while you work. Every time you don't know something, search, read, come back. It's more than enough.
Try it. Seriously.
If you want to go deeper, the professional Claude Code guide is the natural next step. From there you can explore hooks, skills, subagents, MCP, and the Cursor comparison.