Ultimate Guide to Claude Code: Setup, Tips & Advanced Usage

Claude Code represents a fundamental shift in how developers interact with AI assistants. Rather than copying code snippets back and forth between a chatbot and your editor, Claude Code operates directly in your development environment—reading files, executing commands, and making changes autonomously.

This guide will take you from complete beginner to confident Claude Code user, covering everything from installation to advanced customization techniques that will transform your development workflow.

What You'll Learn

How to install Claude Code on any operating system (macOS, Linux, Windows)
Essential commands and keyboard shortcuts for efficient navigation
Configuration options that eliminate friction in your workflow
Advanced customization with hooks, custom commands, and memory systems
Real-world use cases beyond traditional coding
Common pitfalls and how to avoid them
Tips from power users who've integrated Claude Code into their daily workflow

Understanding What Claude Code Actually Does

Before diving into installation, it's worth understanding what makes Claude Code different from regular Claude or other AI coding assistants.

Traditional AI Chat (Claude, ChatGPT, etc.):

You paste code into a chat window
AI suggests changes in text form
You manually copy changes back to your files
Context is limited to what you explicitly share

Claude Code:

Operates directly in your project directory
Reads and understands your entire codebase automatically
Makes changes to files directly (with your permission)
Executes terminal commands
Maintains awareness of project structure, dependencies, and relationships

Think of it as the difference between describing your house to someone over the phone versus having them walk through it with you. Claude Code sees everything in context and can take action immediately.

Pro Tip: Claude Code follows the Unix philosophy—it's composable and scriptable. You can pipe output from other commands into Claude Code or use it in CI/CD pipelines for automated tasks.

Installation Guide

System Requirements

Before installing, verify your system meets the minimum requirements:

macOS: 10.15 (Catalina) or later
Linux: Modern distribution with glibc 2.31+
Windows: Windows 10 or later (with Git Bash)

You'll also need a paid Claude account—either a Claude Pro/Max subscription ($20-100/month) or credits in the Anthropic Console.

Installing on macOS and Linux

The installation process is straightforward. Open your terminal and run:

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

Alternatively, macOS users can install via Homebrew:

bash
brew install --cask claude-code

The installation typically completes in under a minute.

Installing on Windows

Using PowerShell (Recommended):

Open PowerShell as Administrator and run:

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

Using Command Prompt:

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

Using WinGet:

powershell
winget install Anthropic.ClaudeCode

Windows-Specific Requirement: Git Bash

Windows users will likely encounter an error about Git Bash being required:

Claude Code requires git-bash to be installed on Windows.

To fix this:

Navigate to git-scm.com/download/win
Download and run the installer
Accept all default options during installation
Restart your terminal and try the Claude Code installation again

First Launch and Authentication

After installation, navigate to your project directory and launch Claude Code:

bash
cd your-project
claude

On first launch, you'll be prompted to authenticate. You have two options:

Claude Subscription (Recommended): Sign in with your Claude Pro, Max, Teams, or Enterprise account
Anthropic Console: Use API credits from your Console account

Pro Tip: The subscription option provides better value for regular users and unlocks additional features like the Claude Desktop app integration. API credits can burn through quickly—one user reported spending nearly $2 on just two demo tasks using the cheapest model.

Starting Claude Code

The basic command structure is simple:

bash
claude                    # Start interactive session
claude "your prompt"      # Start with an initial prompt
claude -p "prompt"        # Non-interactive mode for scripts

Critical Keyboard Shortcuts

Master these shortcuts to work efficiently:

Action	Shortcut
Stop Claude mid-response	`Escape`
Navigate previous messages	`Up Arrow`
View all previous messages	`Escape` twice
New line in prompt	Set up with `/terminal-setup`
Paste images	`Ctrl+V` (not Cmd+V on Mac)
Exit Claude Code	`Ctrl+C`

Pro Tip: The Escape key is your friend. Unlike traditional terminal programs where Ctrl+C stops processes, in Claude Code Ctrl+C exits entirely. Use Escape to interrupt Claude without losing your session.

Useful Slash Commands

Claude Code includes built-in slash commands for common operations:

text
/clear              # Clear conversation history (use often!)
/terminal-setup     # Configure terminal for better experience
/install-github-app # Set up GitHub PR reviews
/hooks              # Configure automation hooks
/help               # Show all available commands

File and Context Management

Reference files directly in your prompts using the @ symbol:

Can you review @src/components/Button.tsx and suggest improvements?

To add files via drag-and-drop, hold Shift while dragging into the terminal. Without Shift, files open in a new tab instead of being referenced.

Configuration for Maximum Productivity

The Permission System

By default, Claude Code asks permission for nearly every action—editing files, running commands, creating directories. While this is safe, it can severely hamper productivity.

When Claude prompts for permission, you'll see options like:

text
Do you want to allow this action?
1. Yes, allow once
2. Yes, allow for this session
3. No

Option 2 reduces interruptions significantly. For power users comfortable with the risks, you can bypass permissions entirely:

bash
claude --dangerously-skip-permissions

⚠️ Warning: This flag gives Claude Code freedom to edit and delete files without confirmation. Only use this in sandboxed environments or when you have proper backups and version control in place.

Setting Up Your Working Directory

Claude Code can access all files and subdirectories within its working directory. For safety:

Never run Claude Code from your home directory or drive root
Create a dedicated project folder or use existing project directories
Use version control (git) to protect against unwanted changes

Navigate to your project before starting:

bash
cd ~/projects/my-app
claude

Or right-click within a folder in your file explorer and select "Open in Terminal."

Creating a CLAUDE.md File

The CLAUDE.md file provides persistent context about your project. Place it in your project root:

markdown
1# Project Overview
2
3This is a React application using TypeScript and MUI components.
4
5## Key Commands
6
7- `npm run dev` - Start development server
8- `npm run build` - Production build
9- `npm run test` - Run test suite
10- `npm run lint` - Lint codebase
11
12## Architecture Notes
13
14- State management: MobX
15- Styling: MUI v5 with custom theme
16- API calls: React Query with Axios
17
18## Coding Conventions
19
20- Use functional components with hooks
21- Prefer named exports over default exports
22- All components should have TypeScript interfaces

Claude Code reads this file automatically, eliminating the need to explain your project setup in every conversation.

Pro Tip: CLAUDE.md files can be hierarchical. Place one at the project root and additional ones in subdirectories for context-specific information. Claude prioritizes the most specific (deeply nested) file when relevant.

Configuring Hooks for Automation

Hooks allow you to run commands automatically at various points in Claude's workflow. Create a .claude/settings.json file:

json
1{
2  "hooks": [
3    {
4      "matcher": "Edit|Write",
5      "hooks": [
6        {
7          "type": "command",
8          "command": "prettier --write \"$CLAUDE_FILE_PATHS\""
9        }
10      ]
11    },
12    {
13      "matcher": "Edit",
14      "hooks": [
15        {
16          "type": "command",
17          "command": "if [[ \"$CLAUDE_FILE_PATHS\" =~ \\.(ts|tsx)$ ]]; then npx tsc --noEmit --skipLibCheck \"$CLAUDE_FILE_PATHS\" || echo '⚠️ TypeScript errors detected'; fi"
18        }
19      ]
20    }
21  ]
22}

This configuration:

Runs Prettier on any file Claude edits or creates
Runs TypeScript type-checking on edited TypeScript files

Hook types include:

PreToolUse: Before Claude executes a tool
PostToolUse: After Claude completes an action
Notification: When Claude sends notifications
Stop: When Claude finishes responding

Creating Custom Slash Commands

Custom commands live in .claude/commands/ as Markdown files. The filename becomes the command.

Example: /test command

Create .claude/commands/test.md:

markdown
1Please create comprehensive tests for: $ARGUMENTS
2
3Test requirements:
4- Use Jest and React Testing Library
5- Place tests in __tests__ directory
6- Mock external dependencies appropriately
7- Test all major functionality and edge cases
8- Ensure proper cleanup in afterEach
9- Aim for high code coverage

Now /test UserProfile generates tests for your UserProfile component with your preferred testing conventions.

Subfolders work too—.claude/commands/api/endpoint.md becomes /api/endpoint.

Using the Memory System

The # symbol adds information to Claude's memory:

text
# Always use MUI components for new UI elements
# Prefer async/await over .then() chains
# Include JSDoc comments on exported functions

Claude automatically saves these to the appropriate memory file:

Project memory: Saved to CLAUDE.md, shared with team
Local memory: Git-ignored, specific to you
Global memory: Applied across all projects

Where to Use Claude Code

Claude Code runs in multiple environments:

Terminal (CLI)

The core experience covered in this guide. Maximum flexibility and power.

VS Code Extension

Install from the VS Code marketplace. Provides:

Inline diff viewing
@-mentions for files
Plan review before execution
Multiple parallel sessions in different panes

JetBrains Plugin

Available for IntelliJ IDEA, PyCharm, WebStorm, and other JetBrains IDEs with native diff viewing and context sharing.

Claude Desktop App

A standalone application offering:

Visual diff review
Parallel sessions via git worktrees
Ability to launch cloud sessions

Web Interface

Access at claude.ai/code for:

Working on remote repositories
Running parallel tasks
No local setup required

GitHub Actions

Automate code review and issue triage in CI/CD with @claude mentions.

Slack Integration

Mention Claude in Slack to route coding tasks and receive PRs back.

Real-World Use Cases

For Developers

Building Features from Descriptions:

text
1Create a user authentication system with:
2- Email/password login
3- OAuth with Google and GitHub
4- JWT token management
5- Password reset flow
6- Rate limiting on auth endpoints

Claude Code will plan the implementation, create necessary files, and ensure components work together.

Debugging from Error Messages:

text
I'm getting this error when running tests:

TypeError: Cannot read property 'map' of undefined
    at UserList (src/components/UserList.tsx:23:18)

Claude Code analyzes your codebase, identifies the root cause, and implements a fix.

Navigating Unfamiliar Codebases:

text
Explain how the payment processing flow works in this codebase,
starting from when a user clicks "checkout."

Handling Large Files: Claude Code excels where other tools struggle. It successfully handles files of 18,000+ lines that cause other AI assistants to fail with patch resolution or require complete file rewrites.

For Non-Developers

File Organization:

text
Review all files in the Documents folder, rename them based on their content,
create logical category subfolders, and organize files into appropriate folders.

Research and Compilation:

text
Research the top 10 productivity tools for remote teams,
create a comparison spreadsheet with features and pricing,
and save it as productivity-tools-comparison.xlsx

Content Analysis:

text
Analyze all the screenshots in this folder and create a summary document
organizing them by topic with descriptions of each.

GitHub Integration

Set up automated PR reviews:

/install-github-app

Customize the review behavior by editing claude-code-review.yml:

yaml
direct_prompt: |
  Please review this pull request and look for bugs and security issues.
  Only report on bugs and potential vulnerabilities you find.
  Be concise.

This prevents overly verbose reviews that comment on every minor style choice, focusing instead on actual issues.

Advanced Tips and Techniques

Message Queuing

Queue multiple prompts and Claude works through them intelligently:

text
Refactor the authentication module to use the repository pattern

Also add comprehensive error handling

And update the tests to match

Claude recognizes when tasks are sequential and handles them appropriately. If it needs your input, it pauses—otherwise, it continues through the queue.

This enables a powerful workflow: queue up tasks, attend to other work, and return to completed implementations.

Model Selection

Claude Code offers multiple models:

Opus: Most capable, higher token usage
Sonnet: Balanced capability and efficiency

By default, Claude Code uses Opus until you reach 50% of your usage allocation, then switches to Sonnet. You can manually switch models when:

Opus is having issues with a particular task
You want to conserve usage for complex work
Speed matters more than maximum capability

Clearing Context

Use /clear liberally. Starting fresh eliminates:

Irrelevant context from previous tasks
Compaction overhead from summarizing old conversations
Token waste from accumulated history

Clear between unrelated tasks, not just at the start of sessions.

Piping and Scripting

Claude Code integrates with Unix pipelines:

bash
tail -f app.log | claude -p "Alert me if you see any errors in this log stream"

bash
claude -p "If there are new text strings, translate them to French and create a PR"

This enables powerful automation in CI/CD pipelines and scheduled tasks.

Common Pitfalls and How to Avoid Them

Running from the Wrong Directory

Problem: Starting Claude Code from your home directory or drive root gives it access to everything.

Solution: Always navigate to your specific project folder first, or open terminal directly from that folder.

Permission Fatigue Leading to Mistakes

Problem: Approving permissions reflexively without reading what Claude is doing.

Solution: Use session-wide permissions (option 2) for trusted operations, but read file deletion or major restructuring requests carefully.

Not Using Version Control

Problem: Claude makes changes you want to undo, but there's no history.

Solution: Always work in git-initialized directories. Commit before major Claude Code sessions. Use branches for experimental work.

bash
git init
git add .
git commit -m "Before Claude Code session"

Forgetting to Clear Context

Problem: Accumulated conversation history slows responses and wastes tokens.

Solution: Use /clear at the start of each new task.

Copy-Paste Issues on macOS

Problem: Cmd+V doesn't paste images.

Solution: Use Ctrl+V instead for pasting images from clipboard.

Misusing the Stop Command

Problem: Pressing Ctrl+C exits Claude Code entirely instead of stopping the current operation.

Solution: Use Escape to stop Claude mid-response while keeping your session alive.

Security Best Practices

Sandbox your work: Use dedicated project directories, never system-wide access
Use version control: Git provides an undo mechanism for unwanted changes
Review before approving: Read permission requests, especially for deletions or system commands
Avoid sensitive data: Don't place passwords, API keys, or personal documents in Claude Code's working directory
Back up critical files: Maintain backups outside the working directory
Be cautious with downloads: Manually approve requests to download files from the internet

Conclusion and Next Steps

Claude Code represents a genuine leap forward in AI-assisted development. Unlike chat-based assistants that require constant copy-pasting, Claude Code operates as a capable agent within your actual development environment.

The key insights from power users:

Start simple: Use Claude Code for straightforward tasks first, then expand as you build trust
Customize aggressively: Set up CLAUDE.md, hooks, and custom commands to match your workflow
Clear often: Fresh context leads to better results
Queue tasks: Let Claude work while you focus on other things
Trust but verify: Review changes before committing, especially early on

Recommended Next Steps

Install Claude Code and complete your first task in a sandboxed folder
Create a CLAUDE.md for your primary project
Set up one custom slash command for a task you do frequently
Try the VS Code extension or desktop app for a more visual experience
Experiment with the GitHub integration on a low-stakes repository

The developers who've fully adopted Claude Code consistently report that it transforms their relationship with AI assistance—from a conversation partner to a capable collaborator that actually does the work alongside them.

The terminal interface may feel unfamiliar at first, but give it a week. You might find, like many others, that there's no going back.