Frequently Asked Questions

View and edit memory

/memory

Opens an interactive browser showing all CLAUDE.md and rule files loaded in the session, a toggle for auto memory, and a link to open the memory folder. You can also edit files directly at ~/.claude/projects/<project>/memory/.

Disable auto memory

Three methods:

# In a session
/memory   (then toggle off)

# In settings file (.claude/settings.json or ~/.claude/settings.json)
{ "autoMemoryEnabled": false }

# Via environment variable
export CLAUDE_CODE_DISABLE_AUTO_MEMORY=1

Custom memory location

Set in user or local settings (not project settings):

{ "autoMemoryDirectory": "~/my-custom-memory-dir" }

Clear memory

Delete files directly from ~/.claude/projects/<project>/memory/. There is no slash command to bulk-clear memory. You can also ask Claude to forget specific things and it will remove the relevant entries.

Basic compaction

/compact

Claude summarizes earlier parts of the conversation, preserving your requests and key code snippets. Detailed instructions from early in the conversation may be lost, but CLAUDE.md is always re-injected fresh from disk.

Focused compaction

/compact focus on the API changes

Tells Claude what to prioritize when summarizing. Use this to preserve specific context that matters for your current task.

During a session

Press Shift+Tab to cycle through: default, acceptEdits, plan, auto.

At startup

claude --permission-mode plan
claude --permission-mode acceptEdits

As a persistent default

# In .claude/settings.json or ~/.claude/settings.json
{
  "permissions": {
    "defaultMode": "acceptEdits"
  }
}

Interactive setup

/mcp

Shows installed MCP servers, per-server token costs, and options to add or remove servers.

Via settings file

# In .claude/settings.json or ~/.claude/settings.json
{
  "mcpServers": {
    "github": {
      "type": "stdio",
      "command": "npx",
      "args": ["@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "YOUR_TOKEN"
      }
    }
  }
}

At startup

claude --mcp-config ./mcp.json

Continue exactly where you left off

The most direct way to maintain context is to resume the previous session. Claude reloads the full conversation history, including all file reads, edits, and decisions made.

# Resume the most recent session in the current directory
claude -c

# Pick from a list of past sessions
claude --resume

# Resume a specific named session
claude -r "auth-refactor"

# Resume and continue with a new prompt
claude -c "now add the unit tests"

# Inside a session
/resume

When to use: You are continuing the same task from yesterday. You want Claude to remember everything -- the files it read, the approach it chose, and the rationale for decisions.

Limitations: Old sessions eventually exceed the context window. If the session is very long, earlier messages may be auto-compacted. Named sessions make it easier to find the right one later.

Make sessions findable later

Unnamed sessions pile up and become hard to distinguish. Name every session that you might return to.

# Start a named session
claude -n "payment-refactor"

# Rename the current session
/rename checkout-migration

# Resume by name later
claude -r "payment-refactor"

When to use: Any multi-session task. Name by feature, ticket, or branch -- whatever helps you find it in a list of 20 sessions.

Rules that survive every session

CLAUDE.md is re-loaded from disk at the start of every session and re-injected after compaction. It is the most durable form of project context.

# .claude/CLAUDE.md -- always loaded, never lost
## Current Sprint
- Auth migration to Supabase (deadline: April 15)
- Do not modify legacy auth until migration is complete

## In-Progress Work
- Payment refactor: branch payment-v2, PR #142
- Checkout flow: waiting on design review before proceeding

## Decisions Made
- Using Riverpod over Bloc (decided March 15, see ADR-003)
- Storing monetary values as integers in cents

When to use: Project-level context that every session should know. Sprint priorities, in-progress branches, architectural decisions, and constraints that apply to all work.

How to maintain: Update the "Current Sprint" and "In-Progress Work" sections weekly. Remove completed items. Claude reads this every time -- stale entries waste context and cause confusion.

What Claude remembers on its own

Auto memory persists things Claude discovers during sessions -- build commands, debugging patterns, your preferences, and project conventions. It is stored in ~/.claude/projects/<project>/memory/ and the index (MEMORY.md) is loaded at every session start.

# View and manage memory
/memory

# Ask Claude to remember something specific
"Remember that the payments service requires VPN access to test locally"

# Ask Claude to forget something
"Forget what you saved about the old auth system"

When to use: Let it run in the background. Claude will save things that help future sessions -- corrections you give it, patterns it discovers, and solutions to problems it encounters. Review periodically with /memory and prune stale entries.

What it does not do: Auto memory does not save task progress, TODO lists, or debugging logs. It saves patterns and learnings, not ephemeral state.

Commits and branches carry context forward

The most reliable way to carry work between sessions is through git. Commits, branch names, and PR descriptions persist indefinitely and Claude can read them.

# Start a new session and catch up via git
claude
> "Check git log and the open PRs to understand what I was working on yesterday"

# Or be specific
claude -c "I was working on the checkout migration on branch checkout-v2.
Check the recent commits and continue where I left off."

When to use: Always. Commit frequently with descriptive messages. Create PRs with detailed descriptions. When you return to a session, Claude can reconstruct context from the git history even without resuming the old session.

Best practices:

• Commit at natural stopping points, even if the work is incomplete (use a WIP commit on a feature branch)
• Write commit messages that explain why, not just what
• Use PR descriptions to document the overall approach and remaining work
• Branch names should match the task: feature/checkout-migration, fix/payment-rounding

Isolated branches with their own sessions

Git worktrees let you work on multiple features simultaneously, each with its own directory and Claude session.

# Start Claude in an isolated worktree
claude -w checkout-migration

# Each worktree gets its own session history
# Resume a worktree session later
claude -w checkout-migration -c

When to use: You are juggling multiple features or reviewing a PR while working on something else. Each worktree has its own working directory, branch, and Claude session, so context does not bleed between tasks.

Leave breadcrumbs in the code

For fine-grained task tracking within a feature, leave TODO comments in the code itself. Claude can find and act on them in the next session.

// TODO(floyd): Add retry logic for failed payments -- see Stripe docs
// TODO: Validate coupon codes against the promotions table
// TODO: Write integration tests for the checkout flow

When to use: When you stop mid-feature and need to remember specific next steps. In the next session, ask Claude to find and work through the TODOs:

"Find all TODO comments in the checkout feature and work through them"

Write a briefing for the next session

Before ending a session, ask Claude to write a handoff summary that you can paste into the next session.

# At the end of a session
"Write a handoff summary of what we did, what is left to do, and any
decisions we made. I will paste this into our next session."

Claude will produce a structured summary of the work done, open questions, and next steps. Save it in a file, a note, or just copy it. Paste it as the first message of the next session:

# Start of next session
"Here is context from our last session: [paste handoff summary].
Continue with the next item."

When to use: When resuming the old session is not practical (too long, too old, or different machine). The handoff summary is more focused than a full session resume because it captures only what matters for the next step.