Claude Code Overview

Claude Code is a terminal app. Not an IDE plugin, not a web interface — you run it in your terminal, give it tasks, it works on your codebase, you review what it did.

That distinction matters more than it seems.

The Terminal Paradigm

When you use Cursor, you're in your editor. You see the code. You watch the AI make changes inline. You're present for every keystroke.

When you use Claude Code, you describe a task and delegate it. The agent runs, reads files, makes changes, runs commands. You review the result.

This isn't better or worse — it's a different interaction model for different tasks:

Plain text

"Fix the TypeScript error in this function"     → Cursor inline edit
"Rename this function everywhere in the repo"   → Claude Code
"Walk me through what this module does"         → Either works

The key difference is presence. Cursor keeps you present. Claude Code gives you distance.

What Claude Code Can Do

From the terminal, Claude Code can:

Read any file in your codebase
Write and modify files
Run shell commands (with your confirmation)
Use git — reading history, making commits, creating branches
Search your entire codebase
Follow multi-step plans across many files

It's an agent in the full sense: it takes sequences of actions, checks the results, and adjusts based on what it sees.

Pricing

There's no free plan. You pay via:

API usage (pay per token):

Charged per input/output token
Cheaper for light use; more expensive at high volume
Direct access to the Anthropic API

Claude.ai subscription ($20/month):

Fixed monthly cost
Has rate limits — heavy usage will hit them

Claude Max (higher rate limits, higher price):

For heavy professional use
Limits are real even here during peak times

Rate limits are the most common frustration. Even on paid plans, running large agents or using Opus heavily will hit them. This is not a bug — it's a real constraint to plan around.

Budget-conscious alternative: Google's Gemini CLI covers the same terminal paradigm and is free within limits for personal Google accounts. The interaction model is the same; the model is different. A good way to learn the concepts before committing to a Claude Code subscription.

Model Selection

Claude Code gives you a model picker. The three Claude models and when to use each:

Model	Speed	Cost	Best For
Claude Haiku	Fast	Cheapest	Simple, repetitive tasks
Claude Sonnet	Medium	Mid	Daily driver — everything
Claude Opus	Slow	4–6x Sonnet	Hard problems, complex reasoning

Use Sonnet as your default. It handles the vast majority of coding tasks well and doesn't drain API budget or rate limit quota.

Switch to Opus when:

Sonnet has tried and failed multiple times
You're making an architectural decision that's hard to reverse
The problem is genuinely complex and the extra cost is worth it

Use Haiku when:

The task is simple and repetitive
You want to test something quickly
You're running a lot of small operations and cost matters

The insight that matters: model selection is about matching horsepower to the task. Opus on a routine "add this function" task isn't better — it's just slower and more expensive. A clear prompt to Haiku will outperform a vague prompt to Opus.

Installation

Bash

npm install -g @anthropic-ai/claude-code

After installation, authenticate:

Bash

claude

The first run will prompt you to log in with your Anthropic account or provide an API key.

Starting a Session

Bash

# In your project directory:
claude

# With an initial prompt (launches and immediately runs):
claude "what does this project do?"

# Print mode — non-interactive, useful for scripts:
claude -p "run the tests and tell me what failed"

Once in the interactive session:

Plain text

> what does the auth module do?           ← exploration, no changes
> refactor the payment processing module  ← delegates a task
> /help                                   ← see all commands
> /status                                 ← token usage, current model
> /model sonnet                           ← switch models
> /exit                                   ← quit

When Claude Code Shines vs. Cursor

Reach for Claude Code when:

Cross-codebase changes — rename a function, update all callers, update all tests, update the docs. In Cursor, this is awkward because you're looking at one file at a time. In Claude Code, you describe it once.

Running in the background — describe the task, go do something else, come back and review. You're not tied to a window.

Complex multi-step work with a clear plan — give it a CLAUDE.md with a detailed plan, let it execute.

Terminal-native workflows — if you're already in the terminal, using an IDE just for Cursor's agent is friction. Claude Code removes that friction.

Reach for Cursor when:

You're staring at specific code — inline edits, refactoring something you can see on screen.

You want to watch every change — Cursor's inline diff lets you accept/reject each change as it happens.

You're exploring and asking questions — Cursor's chat is more conversational and interactive.

The tools are not competitors. They're different interaction models. Real workflows use both.