Your First Session

Before you type anything, hold one picture in your head. Claude Code is an agent running a loop in your terminal, not an autocomplete that fires once. Give it a goal and it works in three blended phases: gather context (reads files, searches the codebase), takes action (edits files, runs commands), and verifies (runs tests, checks output). The loop is adaptive — a quick question may only gather context; a refactor may run all three many times.

That single fact changes how you work. Because Claude is running over time, you don't have to write the perfect prompt up front and pray. You can watch it work and steer it like a conversation — nudge it when it drifts, correct a wrong assumption, or stop it entirely. And because every edit is snapshotted, a wrong turn is never fatal: you can rewind to any earlier state.

This lesson is a guided first run. By the end you'll have started a session, redirected Claude mid-task, undone a change with a checkpoint, handled a permission prompt, pasted an image, and resumed a session after quitting. Those six moves are the whole game for a beginner — everything else builds on them.

Open your terminal, cd into a project directory, and run claude. The session starts in your current working directory — that's the scope Claude can see and edit.

You have two ways to begin:

# Start an interactive session, then type your task at the prompt
claude

# Or hand Claude a task right on the command line
claude "fix the login bug"

Both land you in the same interactive session; the second just pre-fills your first message. The task can be plain English — Claude figures out which files to read.

First-run login. The very first time you run claude, it walks you through authentication: it opens your browser so you can log in with your Claude subscription (or you can run /login from inside a session). Credentials are then stored for you — encrypted in the macOS Keychain, or in ~/.claude/.credentials.json (mode 0600) on Linux and Windows — so you only do this once per machine.

A reminder from setup: Claude Code is not on the free tier. You need a paid plan — Pro, Max, Team Premium, Enterprise, or Console (API) — to authenticate. A free Claude.ai account can't run it.

Send your task and watch. Claude narrates what it's doing — reading a file, searching for a function, proposing an edit. This visibility is the point: you're not waiting in the dark, you're supervising.

Here's the move that makes you feel in control immediately. If Claude heads the wrong way — editing the wrong file, misunderstanding the goal — press Esc to interrupt it. Esc stops Claude immediately while preserving the work it has already done, so nothing you wanted is thrown away. Then just type a correction and send it.

Claude reads your correction after it finishes the current action, then incorporates it and continues — no restart, no re-explaining the whole task. It's exactly like tapping a colleague on the shoulder: "actually, use the helper in utils.ts, not a new function."

> Refactor the auth code into a service class

[Claude starts editing api/login.ts...]

  (you press Esc)

> Wait — put the service in services/, not api/. And keep the existing function signatures.

[Claude reads the correction, adjusts course, continues]

The habit to build: don't suffer a bad trajectory. The instant Claude drifts, Esc and redirect. It's faster and cheaper than letting it finish, then asking it to undo.

Claude doesn't silently change your machine. By default it runs in a permission mode where it asks before editing a file or running a command. You'll see a prompt that shows exactly what it wants to do — the file and the diff for an edit, or the literal command for a shell run — and you choose: allow it, allow it and stop asking for similar actions this session, or reject and tell Claude what to do instead.

This is the beginner's safety rail. Nothing irreversible happens without your yes. Read the diff in the prompt the way you'd read a teammate's pull request — it's your chance to catch a mistake before it lands.

When you reject a prompt, you're not stuck: you can type why, and Claude adapts. "No — don't delete that file, just comment out the call instead." Rejection is just another form of steering.

A realistic first session looks like a short back-and-forth of approvals: Claude proposes an edit, you approve, it runs the test, you approve, it makes the next edit. That rhythm is normal and it's exactly where your judgment lives.

Even with permission prompts, you'll sometimes approve a change that turns out wrong — or you'll want to try a different approach. That's what checkpoints are for. Claude Code automatically snapshots your code before each edit, and every prompt you send also creates a checkpoint. It's a session-level safety net that lets you pursue ambitious changes knowing you can always return.

To rewind, run /rewind, or press Esc twice when the prompt input is empty. (If there's text in the input, double-Esc clears it instead — that text is saved to your input history, so press Up to recall it.) The rewind menu lists every prompt you sent this session; pick a point, then choose an action:

Restore vs. summarize is the key distinction. Restore actually reverts state — it undoes code, conversation, or both, as if it never happened. Summarize doesn't touch files on disk at all; it just compresses part of the conversation into an AI-generated summary to free up context-window space. Restore is your undo; summarize is your declutter.

Three limits to internalize now, because they catch beginners:

• Checkpoints are session-local and separate from git. They're a fast 'local undo,' not version history. Git is still your permanent record — keep committing.
• File changes only. Checkpoints track edits made by Claude's file-editing tools. Changes from bash commands — rm, mv, cp, git reset — are not captured and can't be rewound. For those, rely on git.
• Auto-cleaned after 30 days (configurable), along with the session itself.

Claude can see, not just read. You can paste an image directly into the prompt and Claude analyzes it as [Image #N]. Two everyday uses:

• A design mockup — paste it and say 'build this component to match,' and Claude compares its implementation against the picture.
• An error screenshot — paste a stack trace or a broken UI and Claude uses it as debugging context, instead of you transcribing the error by hand.

The paste shortcut depends on your platform:

> (Cmd+V to paste a screenshot of the failing page)
  [Image #1]
  This is the 500 error users hit on checkout. Find the cause and fix it.

When you're done, exit with /exit (or just close the terminal). Your session isn't lost. Claude Code stores every session as a JSONL transcript under ~/.claude/projects/, one directory per project. Nothing is uploaded to be 'saved' — it's a local file you own.

To pick up where you left off, cd back into the same project and run:

# Resume the most recent conversation in this directory
claude -c        # or: claude --continue

That reloads your last conversation with full history — Claude remembers what you were doing. If you have several past sessions and want to choose, use claude -r (--resume) to get a picker, or pass an ID or name.

Note a subtlety: each resumed session continues your conversation, but checkpoints persist across sessions too, so you can still rewind to states from a previous run. Your context, your history, and your undo stack all survive a quit.