How to use Claude Code

Anthropic's official agentic coding CLI: runs in terminals and IDEs, handles git workflows, extends via plugins, and integrates with GitHub via @claude mentions.

Claude in a browser chat can describe what to do but cannot actually do it. Claude Code runs in your terminal and IDE with direct access to your codebase, the ability to run tests and builds, full git history, and GitHub integration via @claude mentions in PRs and issues. An extensible plugin system lets you install community skills and build your own. Multi-platform support across macOS, Linux, and Windows makes it the foundation every other tool in this library builds on.

L2L3L4L5L6

Before you startYou need a Claude paid plan (Pro or higher) and a terminal. No Node.js setup required: the current installer handles everything. If you already use Claude at the browser level (Level 1), this is the Level 2 upgrade. Everything else in this resource library runs on top of Claude Code.

Steps

Install Claude Code

The current installer is a one-line script: no Node.js, no npm. Mac, Linux, and WSL use a curl command; Windows uses PowerShell. Mac users can also use Homebrew; Windows users can use winget. Verify with `claude --version` after install.

# Mac / Linux / WSL curl -fsSL https://claude.ai/install.sh | bash # Windows PowerShell irm https://claude.ai/install.ps1 | iex # Alternative: Homebrew (Mac) brew install --cask claude-code # Alternative: winget (Windows) winget install Anthropic.ClaudeCode # Verify claude --version

Authenticate and open your project

Always run `claude` from your project root, not from your home directory. Claude Code reads the directory it starts in as its working context. On first run it will prompt for your Anthropic API key.

cd [YOUR_PROJECT_ROOT] claude

[YOUR_PROJECT_ROOT]Path to your project e.g. /Users/me/projects/my-app

Get your bearings in the first session

Before you write CLAUDE.md, ask Claude Code to orient you. The three answers (what it is and what beats a regular chat, what it can see and change vs what it cannot touch, the one habit that keeps you out of trouble) save you a week of guesswork. Run this in your project root after the first authenticated session.

Give me a short orientation. In plain language, tell me three things: 1. What you are and what you can do that a regular chat window cannot. 2. What you can see and change on this computer right now, and what you cannot touch. 3. The one habit that keeps a beginner out of trouble with you. Keep it brief. No jargon.

Write a CLAUDE.md to give it persistent context

CLAUDE.md is the most important file you will write. It is read at every session start and tells Claude Code how your project is structured, which conventions to follow, and what it should never do. Without it you re-explain your project every session.

Based on the files in this project, write a CLAUDE.md in the root with these sections: 1. Project overview (1-2 sentences) 2. Tech stack (bulleted list) 3. Folder structure (key directories and what they hold) 4. Conventions (naming, imports, test patterns) 5. What NOT to do (hard rules: things you should never change without asking) Keep it under 100 lines. Every sentence should be something a contributor needs to know.

Learn the slash commands that manage long sessions

Four commands matter most at the start: `/clear` resets context when a session drifts. `/compact` compresses long sessions to save tokens. `/checkpoint` writes a state file so you can resume exactly where you stopped. `/model` switches the underlying model without restarting. These four cover the majority of session management you will encounter.

Save a lasting preference with Memory

Claude Code has a Memory tool that stores preferences across sessions, not just within one conversation. Tell it once how you want emails drafted, what voice to use, or what format you prefer. Then ask where it was saved so you can verify the preference is locatable, not vaporware.

Save this as a lasting preference, not just for this conversation: when you draft emails for me, keep them short and casual, three sentences or fewer, no formal sign-off. After you save it, tell me where it was saved and confirm it will apply in future sessions too.

Never rebuild what Claude Code already ships

Before implementing any agentic capability (tool use, memory, multi-file editing, git operations), verify Claude Code does not already have it. The CLI is updated frequently. This prompt evaluates any build-vs-integrate decision before you write a line of custom infrastructure.

I want to add [CAPABILITY] to my Claude Code setup. Before I build it: 1. Does Claude Code already support this natively? Check `claude --help` and recent release notes. 2. Is there a plugin, skill, or community tool that already does this? 3. If I build it myself, what will I have to maintain that I would not have to maintain with an existing solution? End with: use what exists, adapt what exists, or build new.

[CAPABILITY]The capability you want to add e.g. persistent memory that survives session resets

How do you know it worked?

`claude --version` prints a version number without errors.
Claude Code ran from your project root and correctly described the project without prompting.
Your CLAUDE.md has at least 4 of the 5 sections.
You used `/clear` or `/compact` in a session and continued without re-explaining the project.
Your second session started coding without a re-orientation conversation.

If something looks off

Running `claude` from your home directory

Claude Code indexes the directory it starts in. From home it has access to everything and understands nothing specific. Always cd into your project first.

CLAUDE.md that describes what the project will be instead of what it is

Write CLAUDE.md from what exists in the codebase right now, not from the roadmap. Future intentions add confusion; current facts add clarity.

Building capabilities Claude Code already ships

Memory, context management, multi-file editing, test running, git operations. These are all built in. Check the changelog at github.com/anthropics/claude-code/releases before building any agent infrastructure.

Skills & Commands Reference

Core Claude Code CLI commands and launch flags you'll use in every session.

Command / Skill	What it does	When to use it
`claude`	Start an interactive session in the current directory	Beginning any coding task from the terminal
`claude -p "..."`advanced	Headless one-shot prompt, runs, prints output, exits	Scripting, CI pipelines, or chaining Claude with other shell tools
`--allowedTools`advanced	Restrict which tools a sub-agent is permitted to call	Security-sensitive automation or minimal-permission worktrees
`--permission-mode`advanced	Set trust level: acceptEdits, bypassPermissions, or plan	Walkaway runs (acceptEdits) or fully trusted autonomous sessions
`/clear`	Reset the conversation context to zero	Switching tasks or when context budget approaches 80%
`/compact`	Compress the current conversation into a summary to free context	Long sessions approaching the limit without a full reset
`/memory`	View and manage memory entries for the current session	Auditing what Claude currently knows before a complex task
`CLAUDE.md`	Persistent instruction file read at every session start	Encoding project conventions, stack, and hard rules once instead of every session
`Hooks`advanced	Shell scripts that fire on PreToolUse, PostToolUse, Stop, and Notification events	Enforcing gates, logging agent actions, or triggering side-effects automatically
`MCP servers`advanced	Extend Claude's toolset with custom tools via Model Context Protocol	Connecting Claude to databases, APIs, or internal systems
`/plugin`	Install, list, and manage skill plugins from the marketplace or GitHub	Adding community skills or installing tools from this resource library
`@claude (GitHub)`advanced	Mention @claude in a GitHub PR or issue to trigger a Claude Code review or task	Async code review without starting a local session, works directly in GitHub