32 Claude Code Tips: From Basics to Advanced

Claude Code has quickly become a core part of many developers' workflows. But most people barely scratch the surface of what it can do. This guide covers 32 practical tips — from quick quality-of-life improvements to advanced techniques like running Claude Code inside containers and orchestrating multiple AI models.

Tip 0: Customize Your Status Line

You can customize Claude Code's status line to display useful info at a glance — current model, directory, git branch, uncommitted file count, sync status, and a token usage progress bar. A second line can show your last message for quick context recall:

Opus 4.5 | dir:Daft | fix/colab-pydantic-pickle (0 files, synced) | █░░░░░░░░░ 12% of 200k tokens
Last: Okay, and this part I don't quite understand. What is type checking and why are we using it there?

This is especially useful for monitoring context usage and remembering what a conversation was about when switching between tabs.

Tip 1: Talk to Claude Code with Your Voice

Voice input is significantly faster than typing for most people. On macOS, local transcription tools like superwhisper, MacWhisper, or open-source alternatives work well enough. Even when transcription contains errors, Claude is smart enough to interpret what you meant.

![Voice transcription mistakes interpreted correctly](images/claude-code-tips/voice-transcription-mistakes.png)

In this example, mistranscribed words like "ExcelElanishMark" and "advast" were correctly interpreted as "exclamation mark" and "Advanced."

Think of it like sending voice messages to a colleague. You don't need perfect dictation — just speak naturally. If you're in a shared space, whispering into earphones works fine.

Tip 2: Break Down Large Problems

This is fundamental. It's the same principle that makes great software engineers great — decomposition.

If Claude Code can't one-shot a complex task, break it down. If a subtask is still too hard, break it down further. Keep going until everything is solvable.

Instead of jumping straight from A to B:

Go from A to A1 to A2 to A3, then to B.

Example: Building a voice transcription system involves model downloading, voice recording, audio transcription, cursor placement, and UI. Rather than tackling it all at once, build each piece independently — a standalone model downloader, a standalone recorder, a standalone transcriber — then combine them.

Your problem-solving and engineering skills still matter enormously. Claude Code is powerful on its own, but applying structured thinking to how you use it makes it dramatically more effective.

Tip 3: Use Git and GitHub CLI Like a Pro

Let Claude handle your Git and GitHub CLI work. Committing (no more writing commit messages by hand), branching, pulling, pushing — all of it.

A good practice: allow pull automatically but require confirmation for push, since push affects the remote.

For GitHub CLI (gh), get into the habit of creating draft PRs. This lets Claude handle PR creation with low risk — you review everything before marking it ready.

Tip 4: Context Is Milk — Best Served Fresh

Claude Code performs best at the start of a conversation. As context accumulates, performance can degrade. Start a new conversation for each new topic, or whenever you notice quality dropping.

Tip 5: Get Output Out of Your Terminal

Copying from the terminal isn't always clean. Here are better ways:

• /copy — Copies Claude's last response to clipboard as markdown
• Clipboard pipe — Ask Claude to use pbcopy on macOS to send output to clipboard
• Write to file — Have Claude put content in a file and open it in your editor. You can specify a line number for precision
• Open URLs — Ask Claude to open links in your browser with the open command
• GitHub Desktop — Ask Claude to open the current repo in GitHub Desktop, especially useful when working in non-root directories like worktrees

You can combine these too. For example, have Claude copy a PR description to a local file, edit it there, review it yourself, then paste it back.

Tip 6: Set Up Terminal Aliases

Since you'll be living in the terminal more, set up short aliases:

alias c='claude'
alias ch='claude --chrome'
alias gb='github'
alias co='code'
alias q='cd ~/Desktop/projects'

Combine with flags: c -c continues your last conversation, c -r shows recent conversations to resume. These work with all aliases (ch -c, ch -r, etc.).

Tip 7: Proactively Compact Your Context

The /compact command summarizes your conversation to free up context. Auto-compaction triggers when context fills up. On Opus 4.5, the total window is 200k tokens, with ~45k reserved for auto-compaction and ~10% consumed by system prompt, tools, and memory.

A better approach: manually manage compaction. Before starting fresh, ask Claude to write a handoff document:

"Write a handoff document explaining what you've tried, what worked, what didn't, so the next agent with fresh context can pick up where you left off."

Claude creates a summary file. Review it, ask for edits if needed, then start a new conversation and just pass the file path:

> experiments/system-prompt-extraction/NEXT-STEPS.md

The fresh agent can continue from there. In subsequent conversations, ask it to update the document for the next handoff.

Tip 8: Complete the Write-Test Cycle

For autonomous tasks, Claude Code needs a way to verify results. The pattern: write code, run it, check output, repeat.

For interactive terminals (like testing Claude Code itself), use tmux:

tmux kill-session -t test-session 2>/dev/null
tmux new-session -d -s test-session
tmux send-keys -t test-session 'claude' Enter
sleep 2
tmux send-keys -t test-session '/context' Enter
sleep 1
tmux capture-pane -t test-session -p

With a test like this, Claude Code can run git bisect and automatically test each commit to find the one that introduced a bug.

Creative Testing Strategies

For web apps, you can use Playwright MCP, Chrome DevTools MCP, or Claude's native browser integration (/chrome). Playwright generally works better — it focuses on the accessibility tree (structured data) rather than screenshots, making it more reliable.

Use Claude's native browser integration only when you need a logged-in state without providing credentials, or when you specifically need visual coordinate-based clicking.

Tip 9: Cmd+A Is Your Friend

When Claude can't access a URL directly (private pages, blocked sites like Reddit), just select all the content you see (Cmd+A / Ctrl+A), copy it, and paste it into Claude Code. It handles raw text input extremely well.

This works for terminal output too — select all, copy, paste back to Claude Code.

Tip 10: Use Gemini CLI as a Fallback for Blocked Sites

Claude Code's WebFetch can't reach certain sites. Work around this by creating a skill that delegates to Gemini CLI, which has broader web access.

This uses the tmux pattern from Tip 8 — start a session, send commands, capture output. Place the skill file in ~/.claude/skills/reddit-fetch/SKILL.md.

Skills are token-efficient because they only load when needed, unlike CLAUDE.md which loads into every conversation.

Tip 11: Invest in Your Workflow

Take care of your CLAUDE.md. Build custom tools. Learn the features that matter to you.

You don't have to go overboard — even just maintaining a clean, concise CLAUDE.md that helps you achieve your goals makes a real difference. These are investments in the tools you use to build everything else.

Tip 12: Search Through Conversation History

All Claude Code conversation history is stored locally in ~/.claude/. Project-specific conversations live in ~/.claude/projects/, with folder names based on project paths.

# Find conversations mentioning "Redis"
grep -l -i "redis" ~/.claude/projects/-Users-*/*.jsonl

# Find today's conversations about a topic
find ~/.claude/projects/-Users-*/*.jsonl -mtime 0 -exec grep -l -i "keyword" {} \;

Or just ask Claude Code directly: "What did we discuss about X today?" It'll search through history for you.

Tip 13: Multitask with Terminal Tabs

When running multiple Claude Code instances, organization matters more than any specific technical setup. Focus on at most three or four tasks at a time.

Use a "cascade" approach — each new task opens a new tab to the right. Sweep left to right, oldest to newest, checking on tasks as needed.

Tip 14: Slim Down the System Prompt

Claude Code's system prompt and tools consume ~18k tokens (~9% of your 200k context) before you start working. Patching can reduce this to ~10k tokens, saving about 7,300 tokens (41% of static overhead).

The patches trim verbose examples and redundant text while preserving essential instructions. It feels more raw and powerful — more room before context fills up, which means longer conversations.

Lazy-Load MCP Tools

If you use MCP servers, their tool definitions load into every conversation by default. Enable lazy-loading:

{
  "env": {
    "ENABLE_TOOL_SEARCH": "true"
  }
}

Add this to ~/.claude/settings.json. As of version 2.1.7, this happens automatically when MCP tool descriptions exceed 10% of the context window.

Tip 15: Git Worktrees for Parallel Branch Work

Working on multiple branches simultaneously? Git worktrees let you work on different branches in separate directories without conflicts. Just ask Claude Code to create one — you don't need to remember the syntax.

Layer worktrees on top of the cascade tab method for maximum parallelism.

Tip 16: Manual Exponential Backoff for Long Jobs

When waiting on Docker builds or GitHub CI, ask Claude Code to check status with increasing intervals — one minute, two minutes, four minutes, and so on.

For GitHub CI specifically, gh run watch outputs many lines continuously, wasting tokens. Manual backoff with gh run view <run-id> | grep <job-name> is more token-efficient.

Tip 17: Claude Code as a Writing Assistant

Claude Code is an excellent writing partner. The workflow:

1. Give it context about what you're writing
2. Provide detailed instructions via voice
3. Get a first draft
4. Go through it line by line — "I like this line," "move this section there," "change this part"

The back-and-forth iterative process, terminal on the left and editor on the right, produces surprisingly good results.

Tip 18: Markdown Is King

With Claude Code's writing capabilities, markdown becomes the most efficient document format. Blog posts, LinkedIn posts, documentation — talk to Claude Code, save as markdown, go from there.

Quick tip: If you need to paste markdown into a platform that doesn't accept it, paste into Notion first, then copy from Notion to the target platform. Notion converts it to a compatible format.

Tip 19: Use Notion to Preserve Links When Pasting

The reverse works too. If you have text with links from Slack or other apps, paste it into Notion first, then copy from Notion to get clean markdown with links that Claude Code can read.

Tip 20: Containers for Long-Running Risky Tasks

Containerized environments are ideal for --dangerously-skip-permissions sessions. Use them for research, experimentation, and anything that takes a long time or carries risk.

Orchestrating a Worker Instance

Take it further by having your local Claude Code control another instance inside a container via tmux:

1. Local Claude Code starts a tmux session
2. Connects to the container
3. Inside: Claude Code runs with --dangerously-skip-permissions
4. Outer instance uses tmux send-keys and capture-pane for communication

This gives you a fully autonomous worker for experimental or long-running tasks, sandboxed in a container.

Multi-Model Orchestration

Run different AI CLIs in containers — Codex, Gemini CLI, etc. Claude Code becomes the central interface that coordinates everything: spinning up models, sending data between containers and your host.

Tip 21: The Best Way to Learn Is by Doing

Think of it like a billion token rule instead of the 10,000 hour rule. The best way to build intuition for AI is to consume tokens. Use it. A lot. Multiple sessions at a time.

Tips and guides help, but nothing replaces hands-on experience.

Tip 22: Clone Conversations to Branch Off

Want to try a different approach without losing your original thread? Claude Code now has native forking:

• /fork — Forks the current session from within a conversation
• --fork-session — Use with --resume or --continue (e.g., claude -c --fork-session)

Add a shortcut for the flag:

claude() {
  local args=()
  for arg in "$@"; do
    if [[ "$arg" == "--fs" ]]; then
      args+=("--fork-session")
    else
      args+=("$arg")
    fi
  done
  command claude "${args[@]}"
}

Now c -c --fs forks and continues in one command.

Half-Clone to Reduce Context

When a conversation is too long, a half-clone keeps only the later half — reducing token usage while preserving recent work.

Tip 23: Use realpath for Absolute Paths

When telling Claude Code about files in other directories, use realpath to get the full absolute path:

realpath some/relative/path

Simple, but saves confusion.

Tip 24: CLAUDE.md vs Skills vs Slash Commands vs Plugins

These features can be confusing. Here's the breakdown:

• CLAUDE.md — Always loaded into every conversation. Simple, but always present. Good for project context and persistent instructions
• Skills — Like structured CLAUDE.md files, but only loaded when needed. More token-efficient. Can be invoked automatically or manually
• Slash Commands — Similar to skills, but designed primarily for user invocation at a specific time
• Plugins — Packages that can bundle skills, slash commands, agents, hooks, and MCP servers together

Skills and slash commands have been merging in recent versions. The key tradeoff is always-loaded (CLAUDE.md) vs on-demand (skills/commands).

Tip 25: Interactive PR Reviews

Claude Code excels at PR reviews. Retrieve PR info with gh, then go through it however you want — general overview, file by file, or deep dives into specific sections.

The key advantage: it's interactive. Not a one-shot review, but a conversation where you control the pace and depth.

Tip 26: Claude Code as a Research Tool

Claude Code is a powerful research tool. Whether you're investigating GitHub Actions failures, doing sentiment analysis, exploring codebases, or digging into public information — it can handle it.

The key is giving it the right access methods: gh for GitHub, containers for risky operations, Gemini CLI for blocked sites, MCP for Slack and other services, Cmd+A for manual content transfer.

Tip 27: Verify Output in Multiple Ways

Don't rely on a single verification method:

• Tests — Have Claude write and run tests for its own code
• Visual diff — Use a Git client like GitHub Desktop to review changes
• Draft PRs — Create draft PRs and review before marking ready
• Self-check — Ask Claude to double-check its work: "Verify every claim you made and produce a table of what you could confirm"

Tip 28: Claude Code as a DevOps Engineer

For CI/CD failures, Claude Code can dig through logs that would be painful to parse manually. Give it a failing GitHub Actions run and ask it to find the root cause.

Keep pushing if it gives surface-level answers — was it a specific commit? A flaky test? A dependency issue? Once the root cause is identified, have it create a draft PR with the fix.

Tip 29: Keep CLAUDE.md Simple

Start with no CLAUDE.md at all. Only add instructions when you find yourself repeating the same thing. Let Claude Code edit its own CLAUDE.md based on your verbal instructions — it knows exactly what to change.

Less is more. Every token in CLAUDE.md is loaded into every conversation.

Tip 30: Claude Code as the Universal Interface

Claude Code isn't just a coding tool — it's a universal interface to your computer. Quick video edits through ffmpeg, audio transcription with Whisper, data visualization with Python, and with internet access the possibilities are endless.

It's a return to the text interface, but now each terminal tab is an autonomous brain you can delegate work to. As models improve, the proportion of tedious tasks you can offload only grows.

Tip 31: Choose the Right Level of Abstraction

It's not binary between "vibe coding" and "careful engineering." It's a spectrum.

Sometimes flying over the surface is fine — one-time projects, non-critical code. Other times you need to go deep: inspecting file structure, individual functions, specific lines, dependencies.

Think of it like exploring an iceberg. You choose the depth. Claude Code is your guide at every level.