Power Features

Claude Code ships with a set of productivity features that most users never discover. Each one is small on its own, but stacked together they transform how you work. This guide covers eight features that separate casual users from power users.

1. Auto-Memory

Claude remembers things between sessions without you having to repeat yourself. When you correct Claude, share a preference, or establish a project pattern, it can automatically save that context for future sessions.

How It Works

Claude monitors your interactions for reusable context: coding conventions you enforce, tool preferences you state, corrections you make. When it detects something worth remembering, it writes a memory entry to disk.

Memories are stored in your .claude-personal/ directory with a MEMORY.md index file. Each entry includes a timestamp showing when it was last modified, so you can tell at a glance which memories are current.

1.claude-personal/
2├── MEMORY.md              # Index of all memories
3├── preferences/
4│   ├── code-style.md      # "Always use single quotes in TypeScript"
5│   └── testing.md         # "Prefer integration tests over unit tests"
6└── project-patterns/
7    └── api-conventions.md # "API routes return { data, error } shape"

Managing Memories

Use the /memory command to view, edit, or delete stored memories:

/memory           # List all memories
/memory search    # Find specific memories
/memory delete    # Remove a memory

What Gets Saved

The key difference from CLAUDE.md: memories are inferred from your behavior rather than explicitly written. CLAUDE.md is your deliberate configuration; auto-memory captures the patterns you demonstrate through use. Both load at session start, and both shape how Claude works with you.

2. /loop -- Scheduled Tasks

/loop turns Claude into a background worker. Give it a task and a schedule, and it executes on repeat -- like cron, but conversational.

Syntax

/loop 5m /check-deploy       # Run /check-deploy every 5 minutes
/loop 10m review PRs          # Review open PRs every 10 minutes
/loop 1h check test status    # Check CI status every hour
/loop 30m scan error logs     # Monitor logs every 30 minutes

The first argument is the interval (minutes m or hours h), and the rest is the task Claude should perform each cycle.

Use Cases

/loop 5m check if the Vercel deploy finished and report status

Programmatic Control

Under the hood, /loop uses the CronCreate, CronDelete, and CronList tools. You can reference these directly in skills or agent definitions for more precise scheduling control.

/loop is available on all paid plans. Each loop runs in the context of your current session, so it has access to the same tools, files, and MCP servers.

3. Fast Mode

Fast Mode optimizes for speed over deliberation. Same model (Opus 4.6), faster output streaming.

Toggle It

/fast       # Toggle fast mode on/off

When fast mode is active, you'll see an indicator in your prompt. Claude responds noticeably faster, especially for short interactions.

When to Use It

4. /effort -- Model Effort Control

/effort gives you direct control over how much reasoning Claude applies to each response. Think of it as a quality-speed dial.

Effort Levels

/effort low      # Fastest responses, minimal reasoning
/effort medium   # Balanced (default on Max/Team plans)
/effort high     # Maximum reasoning, slowest responses

The "ultrathink" Keyword

If you're on medium or low effort but hit a task that needs deep reasoning, type ultrathink anywhere in your message. Claude will use high effort for that single turn, then return to your default.

ultrathink -- review this authentication flow for security vulnerabilities

This is faster than toggling /effort high and back again. Use it for one-off complex questions in the middle of a fast workflow.

5. Session Management

Sessions in Claude Code are more than just conversation history. You can name them, resume them, fork them, and organize your work across multiple parallel tracks.

Named Sessions

Start a session with a name to make it easy to find later:

claude -n "feature-auth"       # Start a named session
claude -n "bug-memory-leak"    # Another named session

Inside a session, rename it with:

/rename refactor-database

If you don't provide a name, Claude generates one automatically from your first message.

Resuming Sessions

claude --resume                 # Resume the most recent session
claude --resume "feature-auth"  # Resume a specific named session

This restores the full conversation context -- Claude remembers what files it was working on, what decisions were made, and where things left off. Invaluable for multi-day features.

Session Forking

Sometimes you want to explore an alternative approach without losing your current progress. Fork the session:

/fork

This creates a branch of the conversation. You can try a different implementation strategy, and if it doesn't work out, your original session is untouched.

Copying Output

The /copy command copies code blocks or responses to your clipboard:

/copy            # Copy the last response
/copy code       # Copy just the code blocks

Useful for pulling Claude's output into other tools, documentation, or chat messages.

6. /context Command

Long sessions accumulate context. Past file reads, old code blocks, earlier conversation turns -- they all consume your context window. The /context command helps you manage this.

/context

Running /context analyzes your current session and provides actionable suggestions:

• Which parts of the context are no longer relevant
• How much of your context window is consumed
• Specific items you could trim to free up space

Why It Matters

Claude's context window is large but finite. When you approach the limit, responses degrade -- Claude may forget earlier instructions, miss details from files it read earlier in the session, or produce less coherent output.

For very long sessions (multi-hour refactors, extended debugging), proactive context management is the difference between smooth sailing and frustrating repetition. Check /context periodically, especially before starting a new sub-task within the same session.

7. Background Agents

Background agents let you kick off research, analysis, or implementation tasks that run in parallel while you continue working in the foreground.

How It Works

When Claude spawns a background agent, it:

1. Creates a separate execution context
2. Gives the agent its own git worktree (an isolated copy of your repo)
3. Runs the task independently
4. Notifies you when results are ready

You keep working in your main session. No blocking, no waiting.

Research how authentication is implemented across the codebase.
Use a background agent -- I'll keep working on the UI.

Worktree Isolation

Each background agent operates in its own git worktree. This means it can read files, make edits, and even run commands without interfering with your working directory. When the agent finishes, you review its findings or changes before merging them into your work.

This isolation is what makes background agents safe for parallel work -- two agents can edit different files simultaneously without conflicts.

Programmatic Usage

In skill definitions and agent configurations, you can set run_in_background: true on the Agent tool to create background agents programmatically:

1# In a skill or agent definition
2tools:
3  - Agent:
4      task: "Analyze test coverage gaps"
5      run_in_background: true

Stopping Background Agents

Press Ctrl+F to list and kill background agents. It uses a two-press confirmation to prevent accidental termination:

8. Worktree Isolation

Worktrees give Claude an isolated copy of your repository to work in. Changes in a worktree don't affect your working directory until you explicitly merge them. This is the foundation that makes background agents safe, and you can use it directly too.

Starting an Isolated Session

claude --worktree          # Start Claude in a new worktree
claude -w                  # Short form

Claude creates a git worktree, switches to it, and operates there for the entire session. Your main working directory stays untouched.

Why Isolation Matters

Without isolation, two Claude instances (or a Claude instance and your manual edits) can step on each other's files. Worktrees solve this by giving each instance its own filesystem view of the repository.

Sparse Checkouts for Monorepos

For large monorepos, checking out the entire repository into a worktree is expensive. Use worktree.sparsePaths to only check out the directories you need:

1{
2  "worktree": {
3    "sparsePaths": [
4      "packages/frontend/",
5      "packages/shared/",
6      "configs/"
7    ]
8  }
9}

This dramatically reduces the time and disk space required to create worktrees, making isolation practical even in repositories with thousands of packages.

Subagent Isolation

When defining subagents (in skills or agent configurations), you can specify worktree isolation:

agents:
  - name: test-runner
    isolation: "worktree"
    task: "Run the full test suite and report failures"

The EnterWorktree and ExitWorktree tools provide programmatic control for more complex workflows where an agent needs to move between isolated and shared contexts.

Putting It All Together

These features are most powerful in combination. Here's a real-world workflow that uses several of them together:

Quick Reference

Next Steps

• Voice and Remote Execution -- Hands-free coding with voice control and remote Claude sessions
• Plugins and Hooks -- Extend Claude Code with event-driven automation
• Multi-Agent Architectures -- Combine these features into coordinated agent workflows