Module 2: Installation and professional setup

Module 2: Installation and Professional Setup

Next →

Module 2: Installation and Professional Setup

Overview

You already understand what Claude Code is. You know it's Anthropic's coding agent for the terminal, that it leads the SWE-bench benchmarks, and that it operates like a senior developer with full access to your filesystem. That was Module 01. Now comes the part that matters: getting it running.

This module is entirely hands-on. There's no abstract theory — every section pushes you toward a concrete action. By the end of the 5 capsules, you'll have Claude Code installed, authenticated, configured with the right model, and tuned to your workflow. It's the difference between "knowing what Claude Code is" and "having Claude Code working for you."

A good setup is invisible: you don't think about it, it just works. A bad setup is a constant obstacle — authentication errors, the wrong model for the task, unnecessary costs, or worse: not knowing there's a platform that fits your workflow better. This module kills those problems at the root.

Where you are in the guide

Module 01: What is Claude Code ✅
Module 02: Installation and setup ← YOU ARE HERE
Module 03: CLAUDE.md and memory
Module 04: Agentic workflow
Module 05: Skills and Hooks
Module 06: Subagents
Module 07: Integrations (Git, SDK, Remote Control)
Module 08: Capstone project

In Module 01 you learned what Claude Code is, why it leads the space, and how it differs from other agents. Now, in Module 02, we move from understanding to installing and configuring. Everything that comes after — CLAUDE.md, workflows, skills, subagents — depends on getting this step right.

The Core Mental Model

Installing Claude Code is like setting up your development environment.

When you start a new project, you don't jump straight into writing code. First you install the runtime, configure the editor, check that the linter works, confirm the tests pass, and make sure the build pipeline is clean. Only then do you start working.

With Claude Code it's exactly the same:

1. Install Claude Code (native installer, Homebrew, or WinGet)
2. Authenticate (OAuth or API key)
3. Verify it works (/doctor)
4. Pick the right platform (terminal, VS Code, JetBrains...)
5. Select the right plan (Pro, Max 5x, Max 20x)
6. Configure model and effort (Opus 5, Sonnet 5, /effort)

Each step builds on the one before it. Skip the /doctor check and you may be carrying a latent problem that shows up exactly when you need Claude most. Pick the wrong model and you either burn tokens on simple tasks or fall short on complex ones.

The most common mistake

Most users do this:

curl -fsSL https://claude.ai/install.sh | bash
claude
# "it works, done"

They install it, confirm it opens, and start working. They never run /doctor, don't understand the plans, don't know they can switch models mid-session, have never heard of /effort. They operate at 40% of what Claude Code can do.

A professional does this:

curl -fsSL https://claude.ai/install.sh | bash
claude doctor
claude --version
# Sets up the right plan
# Knows the model and effort shortcuts
# Knows which platform to work in for each task

The 30 minutes you invest in this module pay for themselves many times over in every session that follows.

Prerequisites

Required knowledge:

  • ✅ Module 01 completed (you understand what Claude Code is)
  • ✅ Basic familiarity with the terminal / command line

Software you need:

  • ✅ A terminal — macOS Terminal, iTerm2, Windows Terminal, PowerShell, CMD, or any Linux terminal
  • ✅ On Windows: Git for Windows installed (required)

Account required:

If you're on Windows:

Claude Code has native Windows support. You need Git for Windows installed. You can launch claude from PowerShell, CMD, or Git Bash. Optionally, you can also use WSL2 (which additionally supports sandboxing for extra security).

Module roadmap

This module has 5 progressive capsules:

Capsule 01 — Module introduction (this capsule)

Context, mental model, prerequisites, and roadmap. You understand what you're about to do and what you need before starting.

Capsule 02 — Installation and authentication

The central technical step: install Claude Code with the native installer, authenticate, verify with /doctor, and solve the most common problems. At the end you have Claude Code running.

Capsule 03 — Available platforms

Claude Code doesn't live only in the terminal. It exists in VS Code, JetBrains, a desktop app, the web, and even on your phone. Every platform has advantages and limits — here you learn when to use which.

Capsule 04 — Plans, pricing, and models

Pro ($20/mo), Max 5x ($100/mo), Max 20x ($200/mo) — when each one is worth it. Cost optimization strategies. What happens when you hit the usage limit.

Capsule 05 — Model selection and effort level

Opus 5 vs Sonnet 5: when to use each. Effort levels (low, medium, high, max): how to tune the depth of reasoning. The opusplan alias. Optimal combinations for each type of task.

Progression map

Capsule 01 (this one) → Context and prerequisites
Capsule 02            → Installation: from zero to your first "hello"
Capsule 03            → Platforms: where to use Claude Code
Capsule 04            → Plans: what it costs and how to optimize
Capsule 05            → Models and effort: the smart configuration

Difficulty: ⭐ ──────────────────────────▶ ⭐⭐

Capsules 02 and 05 are the most important: without installation there's nothing, and without good model selection you waste resources. Capsules 03 and 04 are strategic context that informs day-to-day decisions.

What you'll achieve in this module

Across the 5 capsules, you'll produce:

  1. Claude Code installed and verified with /doctor showing all green
  2. Authentication configured — API key or OAuth, depending on your use case
  3. An informed platform decision — you'll know which environment to work in
  4. A plan selected — Pro, Max 5x, or Max 20x, based on your profile
  5. Model configuration — when to use Opus, when Sonnet, and at what effort level

Before and after

BEFORE the module:
→ "How do I install Claude Code?"
→ "Why am I getting an authentication error?"
→ "How much does this cost?"
→ "Which model should I use?"

AFTER the module:
→ Claude Code installed and verified
→ Solid authentication, no errors
→ A plan optimized for your usage profile
→ Model and effort configured by task type
→ A platform chosen to fit your workflow

What this module does NOT cover

To keep the focus tight, these things are covered in later modules:

TopicWhere it's covered
CLAUDE.md and the memory systemModule 03
Agentic workflow (explore → plan → code)Module 04
Skills and HooksModule 05
SubagentsModule 06
Integration with GitHub, SDK, CI/CDModule 07
The full capstone projectModule 08

This module is pure setup. It's the foundation everything else is built on.

Connection to the capstone project

In Module 08, you'll build a complete tool using Claude Code. For that project you need:

  1. Claude Code installed — obvious, but it has to be up to date and working
  2. Frictionless authentication — you don't want your token expiring in the middle of a development session
  3. The right plan — the capstone requires long interactions, and an inadequate plan holds you back
  4. The right model — for architecture you'll use Opus + high effort, for implementation maybe Sonnet + medium
  5. The right platform — probably terminal for most of it, but VS Code can help with visual debugging

Everything you configure in this module is exactly what you need for the final project.

Key concepts you'll see

Native installer

Claude Code installs with a native installer that requires neither Node.js nor npm. It auto-updates in the background to keep you on the latest version. It's also available via Homebrew (brew install --cask claude-code) and WinGet (winget install Anthropic.ClaudeCode).

# macOS, Linux, WSL:
curl -fsSL https://claude.ai/install.sh | bash

# Windows PowerShell:
irm https://claude.ai/install.ps1 | iex

# Now 'claude' is available from any directory

OAuth vs API Key authentication

Two ways to authenticate. OAuth is for interactive use (the "normal" experience). An API key is for programmatic use (SDK, headless, CI/CD). Each has its own use case.

OAuth:
→ You run 'claude', the browser opens, you log in
→ For your daily use in the terminal or IDE

API Key:
→ You set ANTHROPIC_API_KEY as an environment variable
→ For CI/CD, scripts, automation

/doctor

Claude Code's diagnostic command. It checks your installation: authentication, connectivity, model access. It's your first line of defense against problems. You run it as claude doctor from the terminal.

claude doctor
# ✓ Authenticated
# ✓ Network OK
# ✓ Model access: Opus 5, Sonnet 5

Platforms

Claude Code isn't just the terminal. It has extensions for VS Code and JetBrains, a standalone desktop app, a web version, and even access from your phone. Each platform offers a different experience.

Terminal (CLI) ← the complete experience
VS Code        ← built into the editor
JetBrains      ← IntelliJ, WebStorm, PyCharm...
Desktop App    ← standalone application
Web            ← claude.ai/code, tasks that keep running without your laptop

Plans (Pro, Max 5x, Max 20x)

Subscription tiers that determine how much you can use Claude Code, which models are available, and what extra features you get access to.

PlanPriceUsageOpus 5
Pro$20/moBaseLimited
Max 5x$100/mo5xFull
Max 20x$200/mo20xFull + priority

Models (Opus 5, Sonnet 5)

Two main models with different profiles. Opus is the most capable (1M context), Sonnet is the best speed/intelligence balance (also 1M context). Haiku is the fastest (200K). The model you pick directly affects the quality and speed of the answers.

Opus 5:   ████████████ capability   ████ speed
Sonnet 5: ████████ capability       ████████████ speed

Effort level

Controls how much the model reasons before answering. The available levels depend on the model:

  • Opus 5: 5 levels — low, medium, high, xhigh, max. Default: xhigh
  • Opus 5, Sonnet 5, and Fable 5: 5 levels — low, medium, high, xhigh, max. Default: high (xhigh recommended for coding)

You set it with /effort, inside /model using the arrow keys, in settings, or via an environment variable.

Effort low    → light reasoning, fast answer
Effort medium → fewer tokens, for cost-sensitive work
Effort high   → deep reasoning, the minimum for intelligence-sensitive work
Effort xhigh  → very deep, recommended for coding/agentic (default on Opus 5)
Effort max    → maximum depth, no thinking-token limit (applies to the current session only)

Note: If you set a level the active model doesn't support (e.g. xhigh on Sonnet 5), Claude Code falls back to the highest supported level (high in that case).

FAQ before you start

"Do I need to know how to program to use Claude Code?"

Yes. Claude Code is a tool for developers. It isn't a "build my app without code" product — it's an agent that works with you, in your code, with your tools. You need to understand code to evaluate what it produces, correct it when it's wrong, and give it precise instructions.

"Does Claude Code work offline?"

No. Claude Code needs an internet connection to talk to Anthropic's servers. The models (Opus 5, Sonnet 5) run in the cloud, not on your local machine.

"Is it safe? Does it read all my code?"

Claude Code reads files in your project to give you contextual answers. Those files are sent to Anthropic's servers for processing. Anthropic has privacy policies and doesn't use your data for training (check anthropic.com/privacy). If you work with sensitive code, review your company's policies before using AI tools.

"Can I use Claude Code with any language?"

Yes. Claude Code works with any programming language: Python, JavaScript, TypeScript, Go, Rust, Java, C#, Ruby, PHP, Swift, Kotlin, and more. There's no language restriction — if you can work with it in your terminal, Claude Code can help you.

"How much space does the installation take?"

Claude Code is relatively light. It doesn't require a GPU or special hardware — just 4 GB+ of RAM and an internet connection. The requirements are minimal: macOS 13+, Windows 10 1809+, or Ubuntu 20.04+.

Versions and compatibility

This module covers:

  • Opus 5 (1M token context window)
  • Sonnet 5 (1M token context window)
  • Haiku 4.5 (200K token context window)

A note on updates:

Claude Code updates frequently. The installation steps and the concepts in this module are stable — native installation, authentication, /doctor, platforms, plans, and model selection are fundamental to the architecture. The specific details (prices, exact limits, features per plan) may evolve; the principles won't.

Whenever you see pricing or limit information, check claude.ai/pricing to confirm the current values.

How to work through this module

Recommendation:

  1. Read capsule 02 with your terminal open. Install Claude Code as you read.
  2. Capsule 03 is informational. Read it to know your options, but you don't need to install every platform.
  3. Capsule 04 requires a decision. By the end of it, you should know which plan you need.
  4. Capsule 05 is hands-on. Experiment with /model and /effort in your terminal.

Estimated time:

Capsule 01 (this)  →  5 min reading
Capsule 02         → 15 min reading + 10 min practice
Capsule 03         → 10 min reading
Capsule 04         →  8 min reading + 5 min decision
Capsule 05         → 12 min reading + 10 min practice

Total: ~75 minutes (reading + practice)

Don't rush. It's better to invest time here and end up with a solid setup than to race toward Module 03 with a fragile installation.

Summary

This module turns "I know what Claude Code is" into "I have Claude Code running professionally."

What it covers:

  • Complete installation (native, Homebrew, WinGet) and authentication
  • Verification with /doctor and troubleshooting
  • The 5 available platforms and when to use each
  • The 3 subscription plans and how to choose
  • Model selection (Opus vs Sonnet) and the /effort parameter

What it produces:

  • Claude Code installed, authenticated, and verified
  • An informed platform and plan decision
  • Model and effort configuration ready to use

Why it matters:

  • A solid setup is invisible — it just works
  • A weak setup creates constant friction that eats your productivity
  • The decisions in this module affect every future session with Claude Code

Next capsule: 02 - Installation and authentication — from zero to your first interaction with Claude Code.

Additional resources

Official documentation

Platform setup

Pricing and plans

  • Claude Pricing — Up-to-date prices for Pro, Max, Team, and Enterprise
  • Manage Costs — Guide to cost optimization in Claude Code

Models

← PreviousThe AI Coding Tools LandscapeNext →Installing and Authenticating Claude Code