Getting Started with Claude Code: The AI Coding Agent That Lives in Your Terminal

I’ve been using AI coding tools for a while now. Copilot in VS Code, ChatGPT for debugging, the usual suspects. They’re helpful, sure, but they all share the same limitation: you copy-paste code out of a chat window and hope it works in your project.

Claude Code is different. It’s an agentic coding tool that runs right in your terminal, reads your actual files, runs your actual commands, and makes changes to your real codebase. No more switching windows. No more context switching. You describe what you want, and Claude Code builds it.

In this post, I’ll walk you through installing Claude Code, configuring it for your projects, and using it to get real work done. By the end, you’ll have a working setup and a solid understanding of when this tool actually saves you time.

Prerequisites

Before we start, make sure you have:

• macOS 13+, Ubuntu 20.04+, Debian 10+, or Windows 10+ (we’ll cover all platforms)
• 4 GB+ RAM and a modern processor (x64 or ARM64)
• Node.js 18+ (for the npm fallback install method)
• Git installed
• An internet connection
• An Anthropic account (free to create, $5 in API credits included)

If you’re on Windows, you’ll also need Git for Windows unless you’re using WSL.

1. Install Claude Code

There are a few ways to install Claude Code. I’ll show the recommended method first, then alternatives.

macOS and Linux

The fastest way is the native installer:

curl -fsSL https://claude.ai/install.sh | bash

If you’re a Homebrew person (I am), you can also grab it from there:

brew install --cask claude-code

The native installer auto-updates in the background. Homebrew doesn’t, so you’ll need to run brew upgrade claude-code manually when you want the latest version.

Windows

From PowerShell:

irm https://claude.ai/install.ps1 | iex

Or from CMD:

curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

Windows users can also install via WinGet:

winget install Anthropic.ClaudeCode

Verify the installation

No matter which method you used, confirm it’s working:

claude --version

If something went wrong, run claude doctor for a detailed diagnostic.

2. Authenticate

Launch Claude Code in your terminal:

claude

On first run, it walks you through authentication. You can sign in with your Anthropic account (which gives you Claude Pro or Max plan access) or connect with an API key from platform.claude.com.

If you’re just trying it out, the API route is simpler. New Anthropic API accounts come with roughly $5 in free credits. That’s enough for several sessions with the Sonnet model to decide if you like it.

3. Your First Session

Navigate to a project directory and fire it up:

cd ~/projects/my-app
claude

You’ll see the Claude Code prompt. Try something simple to get a feel for how it works:

> List the main files in this project and explain the overall architecture

Claude Code will read your file system, examine your code, and give you an actual answer based on your real project. Not a generic template. Your actual code.

Now try something more hands-on:

> Add input validation to the signup form. Email must be valid format, password must be at least 8 characters with one uppercase letter.

Claude Code will figure out which files to modify, write the code, and show you a diff before applying changes. You approve or reject each change. You stay in control.

4. Configure Your Project with CLAUDE.md

This is where Claude Code goes from “neat demo” to “actually useful for daily work.”

CLAUDE.md is a configuration file you place in your project root (or at .claude/CLAUDE.md). Claude reads it at the start of every session. It’s where you tell Claude about your project conventions, coding standards, and preferences.

You can generate a starter file automatically:

claude /init

This scans your project and creates a reasonable CLAUDE.md based on your directory structure and tech stack. Then you refine it.

Here’s what a practical CLAUDE.md looks like for a Laravel project:

# Project: My Laravel App
## Tech Stack
- PHP 8.3, Laravel 11
- MySQL 8.0
- Vue 3 + Inertia.js for frontend
- Tailwind CSS
## Code Style
- Follow PSR-12 coding standard
- Use typed properties and return types everywhere
- Prefer collection methods over raw loops
- Route model binding over manual lookups
## Testing
- Run tests with: `php artisan test`
- Test directory: `tests/`
- Always write feature tests for new endpoints
## Commands
- Start dev server: `php artisan serve`
- Run migrations: `php artisan migrate`
- Clear cache: `php artisan optimize:clear`
- Format code: `./vendor/bin/pint`
## Conventions
- Database migrations use snake_case column names
- API routes are prefixed with `/api/v1/`
- All controllers use Form Requests for validation
- Use repository pattern for complex queries

Why does this matter? Without CLAUDE.md, Claude makes reasonable guesses about your project. With it, Claude follows your actual conventions. It uses your test runner, your code style, your architecture patterns. The difference in output quality is significant.

5. Extend Claude with Skills

Skills are reusable instruction sets that Claude can invoke on demand. Think of them as saved prompts for procedures you do repeatedly.

Create a personal skill:

mkdir -p ~/.claude/skills/deploy

Then write ~/.claude/skills/deploy/SKILL.md:

---
name: deploy
description: Deploys the current project to production. Run tests, build assets, push to server.
---
When deploying this project:
1. Run the test suite and confirm all tests pass
2. Run `npm run build` to compile frontend assets
3. Switch to the `main` branch and pull latest changes
4. Run database migrations on the production server
5. Clear all caches
6. Verify the site is responding correctly
If any step fails, stop and report the error. Do not proceed past a failure.

Now you can invoke it with /deploy in any Claude Code session, and Claude will follow those steps on your actual project. Skills can live at three levels:

• Personal (~/.claude/skills/) – available across all your projects
• Project (.claude/skills/) – scoped to one project, committed to git
• Enterprise (managed settings) – shared across an organization

I keep a handful of personal skills for things like creating database migrations, writing tests, and reviewing pull requests. Project-level skills are great for team-specific workflows.

6. Choosing the Right Model and Managing Costs

Claude Code supports multiple Anthropic models, and your choice has a big impact on both quality and cost.

Sonnet 4.6 is the sweet spot for most coding tasks. It handles 80% of what I throw at it, at $3 per million input tokens and $15 per million output tokens. Fast, capable, and affordable.

Opus 4.6 is for the hard stuff: complex multi-file refactors, tricky debugging across services, architectural decisions. It costs $5/$25 per million tokens, so I only reach for it when Sonnet gets stuck.

Haiku 4.5 is the budget option at $1/$5 per million tokens. Good for quick lookups, simple file edits, and documentation generation.

Switch models mid-session with:

> /model sonnet
> /model opus
> /model haiku

Pricing paths

You have three ways to pay for Claude Code:

Path	Cost	Best for
Claude Pro	$20/month	Moderate daily use
Claude Max	$100-200/month	Heavy users (saves ~93% vs API)
API pay-as-you-go	Per-token, starts at $3/MTok	Light or occasional use

New API accounts get $5 in free credits. If you’re evaluating Claude Code, that’s enough for several sessions without spending anything.

Tip: Set a budget cap to avoid surprises: claude --max-budget-usd 5.00 limits a session to $5 of API usage.

7. Practical Tips from Real Usage

After using Claude Code across several projects, here’s what actually makes a difference:

Give Claude a way to verify its work

This is the single most important thing. Instead of saying “add validation to the form,” say “add validation to the form and run the tests to confirm it works.” Claude performs dramatically better when it can check its own output.

Keep your CLAUDE.md focused

Don’t dump your entire README into CLAUDE.md. Keep it to conventions, commands, and constraints. If a section has grown into a full procedure, extract it into a skill instead.

Use /compact when context gets long

Claude’s context window fills up fast during long sessions. When you notice it starting to forget earlier instructions or making more mistakes, run /compact to summarize the conversation so far and free up space.

Break large tasks into smaller ones

“Build me an entire e-commerce platform” will produce mediocre results. “Create a Product model with title, price, description, and category fields, then write the migration and factory” will produce excellent code. Small, specific prompts win.

Review every change

Claude Code shows you diffs before applying changes. Actually read them. I’ve caught mistakes this way, especially in edge cases the model didn’t fully understand. The approve/reject flow exists for a reason.

8. Common Pitfalls

Claude keeps “forgetting” instructions. This usually means your context window is full. Run /compact or start a fresh session.

It modifies the wrong files. Make sure your CLAUDE.md clearly describes your project structure. The more Claude understands your codebase layout, the better it navigates.

Changes don’t match my code style. Add your style rules to CLAUDE.md. Be specific: “use arrow functions,” “prefer const over let,” “no semicolons.” Claude follows explicit instructions well.

API costs are higher than expected. You’re probably using Opus for everything. Switch to Sonnet for routine tasks and reserve Opus for the complex stuff. Or consider the Max plan if you’re a heavy user.

Should You Use Claude Code?

Claude Code isn’t a replacement for knowing how to code. It’s a force multiplier for developers who already understand their codebase and just want to move faster.

It shines in these scenarios:

• Greenfield features where you describe what you want and Claude scaffolds it
• Refactoring across multiple files where manual edits are tedious and error-prone
• Boilerplate generation like migrations, tests, and CRUD operations
• Learning new codebases by having Claude explain the architecture

It struggles with:

• Ambiguous requirements (garbage in, garbage out)
• Highly specialized domains without context in CLAUDE.md
• Very large codebases that exceed what fits in context

If you spend most of your day writing code in a terminal anyway, Claude Code fits naturally into your workflow. It doesn’t ask you to change how you work. It just makes the work go faster.