Claude Code: From Zero to Productive in 30 Minutes

What You’re Getting Into

Claude Code is Anthropic’s terminal-native coding agent. It reads your entire codebase, writes and edits files, runs shell commands, executes tests, and makes git commits — all from your terminal. It’s not a chatbot with code formatting. It’s an agent that operates directly on your file system.

This guide assumes you have a terminal and a project. By the end, you’ll have Claude Code installed, configured, and actually shipping code with it.

Installation (2 minutes)

The recommended way to install Claude Code is via the official installation script:

# Install stable version
curl -fsSL https://claude.ai/install.sh | bash

# Or install the latest release for early features
curl -fsSL https://claude.ai/install.sh | bash -s latest

The npm installation method is now deprecated. After installation, navigate to your project and run:

cd your-project
claude

First run will open a browser window to authenticate with your Anthropic account. You need either:

A Claude Pro ($20/mo) or Claude Max ($100/mo or $200/mo) subscription
An Anthropic API key with credits

Once authenticated, you’re in. That’s it.

The Commands That Matter

You don’t need to memorize much. Claude Code is conversational — you type what you want in plain English. But these built-in commands save real time:

Command	What It Does
`/init`	Scans codebase (up to 1M tokens) and creates a CLAUDE.md file
`/compact`	Compresses conversation history to save context window
`/clear`	Starts a fresh conversation
`/cost`	Shows token usage and cost for the current session
`/help`	Lists all available commands

The most important one is /init. Run it immediately in a new project. It utilizes the expanded 1M token context window to build a deep understanding of your codebase right from the start.

CLAUDE.md: The File That Changes Everything

When you run /init, Claude Code creates a CLAUDE.md file in your project root. This is a set of persistent instructions that Claude reads at the start of every session. It’s the single highest-leverage thing you can configure.

A good CLAUDE.md includes:

# Project: My SaaS App

## Tech Stack
- Next.js 15 with App Router
- TypeScript (strict mode)
- Tailwind CSS
- Supabase (Postgres + Auth)
- Deployed on Vercel

## Conventions
- Use server components by default, client components only when needed
- All database queries go through src/lib/db.ts
- API routes follow REST conventions in src/app/api/
- Tests use Vitest, run with `npm test`
- Commit messages follow conventional commits

## Important Context
- Auth is handled by Supabase, not custom JWT
- The pricing table pulls from Stripe, don't hardcode prices
- Environment variables are in .env.local (never commit this)

Without CLAUDE.md, Claude has to infer your conventions from code. With it, Claude already knows your stack, patterns, and rules before you type a single prompt.

Pro tip: You can also create ~/.claude/CLAUDE.md for global instructions that apply to all your projects (like “always use TypeScript” or “I prefer functional components”).

Permission Modes: Understanding the Safety Model

Claude Code has three permission modes that control how autonomous it can be:

Default Mode

Claude asks permission before:

Writing or editing files
Running shell commands
Making git commits

This is safe but slow. You’ll be hitting “approve” constantly.

Allowlist Mode

You pre-approve specific actions. For example, allowing file writes but still requiring approval for shell commands. Good middle ground.

Bypass Permissions (YOLO Mode)

claude --dangerously-skip-permissions

Claude does everything without asking. Writes files, runs commands, installs packages, commits code. Now available in Claude Code Desktop too.

When to use YOLO mode: In a git-tracked project where you can easily revert changes. On a feature branch. When you’re prototyping and want maximum speed.

When NOT to use it: On main/production branches. With access to production databases. When running in a directory with sensitive credentials.

Real Workflow Patterns

Pattern 1: Bug Fix (5 minutes)

You: There's a bug where the login form submits twice when you
double-click. Fix it.

Claude will:

Search your codebase for the login form
Identify the double-submit issue
Add a loading state or debounce
Show you the diff
Apply the change (with your approval)

Pattern 2: New Feature (15-30 minutes)

You: Add a dark mode toggle to the site header. Use the existing
Tailwind dark: classes. Store preference in localStorage. Default
to system preference.

Claude will plan the implementation, create components, wire them up, and test. For multi-file changes, it thinks through the order of operations.

Pattern 3: Refactoring with Tests

You: Refactor the user service to use the repository pattern.
Keep all existing tests passing. Add tests for the new repository
layer.

This is where Claude Code shines compared to IDE tools — it can read your entire codebase, understand the patterns, make changes across many files, and run your test suite to verify nothing broke.

Pattern 4: Understanding Unfamiliar Code

You: I just inherited this project. Explain the architecture.
What does the data flow look like from API request to database?

Claude reads the entire project and gives you a coherent explanation. Much faster than reading through files yourself.

Cost Management

Claude Code uses your API credits or subscription. Here’s what things actually cost:

Claude Pro ($20/mo): Includes Claude Code usage with rate limits. Good enough for most individual developers.
Claude Max ($100/mo): 5x the usage of Pro. For heavy daily use.
Claude Max ($200/mo): 20x Pro usage. For teams or power users who run Claude Code all day.
API key: Pay per token. Claude Sonnet 4.5 is $3/$15 per M tokens. A typical coding session uses $0.50-5.00.

To monitor costs: Use /cost during a session, or check your Anthropic dashboard.

To save tokens: Use /compact when conversations get long. Start new sessions (/clear) for unrelated tasks rather than continuing in the same thread.

Tips From Heavy Users

Be specific. “Fix the auth” is worse than “The JWT refresh token isn’t being sent with the refresh request in src/lib/auth.ts.”
Give context upfront. “We use Supabase for auth, not custom JWT” saves Claude from going down the wrong path.
Use it for tests. “Write tests for the user service” is one of the highest-ROI prompts. Claude generates comprehensive test suites that would take you 30+ minutes to write.
Let it commit. Claude writes good commit messages. If you’re on a feature branch, let it git add and git commit as it goes.
Don’t fight it on code style. Put your style preferences in CLAUDE.md and let Claude follow them. Arguing about formatting mid-task wastes tokens.
Use it for code review. Paste a PR diff or point it at changed files: “Review these changes for bugs and security issues.”

What Claude Code Is Bad At

Being honest about limitations saves frustration:

Large-scale architecture migrations. It can refactor files, but rearchitecting an entire app needs human judgment about trade-offs.
Pixel-perfect UI work. It writes functional UI code but doesn’t see the result. Describe visual issues precisely.
Anything requiring secrets/credentials. Don’t pass API keys through prompts. Use environment variables.
Long-running tasks without /compact. The context window fills up. Compact regularly on big tasks.

Next Steps

Read the full Claude Code review for capabilities and pricing details
Check out Claude Opus 4.6 — the model behind Claude Code’s most capable mode
Compare Claude Code vs Codex or Claude Code vs Aider to see how it stacks up