25 Advanced Claude Code Tips: From Power User to Pro

Key Takeaways#

• Context is your most expensive resource — manage it aggressively with /clear, /catchup, and the document-and-clear pattern to avoid degraded performance.
• Match your mode to the task — plan mode for strategy, auto mode for execution, acceptEdits for trusted codebases. One size does not fit all.
• Effort levels and model switching are free levers — use low effort for trivial tasks, high for most work, xhigh for Opus-level reasoning; switch models mid-session with /model.
• Git integration is a first-class workflow — let Claude commit, branch, and create draft PRs; resume directly from PRs with --from-pr.
• Autonomous patterns require guardrails — always set --max-turns, use tmux for persistence, and give Claude a verification loop (tests, bisect, lint) so it can self-correct.

---

Context Management#

Tip 1: Don't Trust Auto-Compact — Use /clear + /catchup Instead#

Auto-compact kicks in when you hit the context limit and silently summarizes older messages. The summary is lossy — nuanced decisions, edge cases, and half-implemented plans get flattened. Instead, force a clean reboot: run /clear to wipe context, then /catchup to let Claude re-read key files and get back up to speed. You control what survives the reset; auto-compact decides for you, badly.

Tip 2: Document-and-Clear Pattern for Complex Tasks#

When a task spans multiple sessions, don't try to keep everything in context. Before clearing, ask Claude to dump its current plan, progress, and open questions to a markdown file (e.g., PLAN.md). Then /clear, start a fresh session, and ask the new Claude to read PLAN.md first. This pattern gives you a perfect handoff — zero context decay, full continuity. It also creates an audit trail you can diff between sessions.

Tip 3: Use /context Mid-Session to Monitor Token Usage#

Run /context periodically to see how much of your 200k token window you've consumed. A fresh monorepo load costs roughly 20k tokens baseline — that's 10% of your context gone before you type a single prompt. Large file reads, verbose logs, and long conversation threads eat the rest fast. If you're past 60%, start thinking about a /clear cycle.

---

Plan Mode & Effort#

Tip 4: Use Plan Mode for Complex Tasks Before Executing#

Run claude --permission-mode plan (or /plan mid-session) when you're facing a multi-step refactor, architecture change, or anything where the wrong approach is expensive to undo. Plan mode lets Claude think through the approach, lay out steps, and identify risks — all without writing a single line of code. Review the plan, adjust it, then switch to auto or default mode to execute. You save context tokens and avoid rollback waste.

Tip 5: Effort Levels Are a Dial, Not a Switch#

• low — quick answers, trivial edits, one-liners. Fast, cheap, sufficient.
• medium — moderate tasks, standard refactors.
• high — default for most users. Thorough reasoning, careful edits.
• xhigh — Opus 4.7 territory. Use for complex debugging, multi-file architectural reasoning, or when high effort isn't producing results.
• max — maximum reasoning budget. Reserve for the hardest problems.

Set with /effort high or --effort high. Use /effort auto to reset to the default. Don't default to max — you burn tokens and latency for no gain on simple tasks.

Tip 6: Switch Models Mid-Session with /model#

Use /model to swap between Sonnet and Opus without restarting your session. Start with Sonnet for speed on routine work (file generation, simple edits, boilerplate). Switch to Opus when you hit a hard problem (subtle bugs, architecture decisions, complex refactors). Your context carries over — you're not starting over, you're escalating.

---

Auto Mode & Permissions#

Tip 7: Auto Mode No Longer Requires --enable-auto-mode#

As of v2.1.111+, --permission-mode auto works directly — no --enable-auto-mode flag needed. This removes the friction of running Claude in CI or autonomous workflows. Just set the permission mode and go.

Tip 8: Use Permission Modes Strategically#

• default — Claude asks before running commands and editing files. Best for exploration.
• acceptEdits — auto-approves file edits, still asks for commands. Best when you trust the codebase but want to review shell commands.
• plan — read-only. Claude can think but not act. Best for strategy sessions.
• auto — auto-approves everything. Best for CI pipelines and autonomous runs where no human is watching.

Don't leave auto mode on for interactive sessions. One wrong rm -rf approved without review and you'll learn the hard way.

Tip 9: Allow Pull Automatically, but NOT Push#

In your permission config, auto-approve git pull and git fetch — they're read-only and safe. Never auto-approve git push. Pushing to origin is irreversible and contaminates the remote. If Claude pushes broken code, every teammate pulls it. Set your .claude/settings.json allowlist to include pull/fetch but explicitly exclude push.

---

Git Integration#

Tip 10: Let Claude Handle Committing and Branching#

Claude generates good commit messages — they reference the what and why, not just the what. Let it commit incrementally as it works rather than one giant commit at the end. Same for branching: tell Claude to create a feature branch at the start and it keeps your main branch clean. You review the commits later; the alternative is one massive "did stuff" commit you can't bisect.

Tip 11: Use gh CLI for Draft PRs#

Tell Claude to create PRs as drafts: gh pr create --draft. Draft PRs are low-risk — they signal "work in progress, don't merge" and give you a URL to review the diff in the GitHub UI. Review the changes, run CI, then mark ready when you're confident. This is the safest PR workflow with AI-generated code.

Tip 12: Resume Sessions from PRs with --from-pr#

Run claude --from-pr 123 to pick up exactly where you left off on a PR. Claude reads the PR description, comments, and diff, then continues work in context. No need to re-explain what the PR does or where you were. This is the fastest path from PR feedback to fix.

---

Voice Input & Accessibility#

Tip 13: Voice Transcription Is Faster Than Typing#

Use tools like superwhisper, MacWhisper, or open-source Whisper clients to dictate prompts instead of typing them. Complex prompts with multi-step instructions are painful to type but natural to speak. Voice input also forces you to think through the full request before sending it, which leads to better prompts and fewer "oh wait, I forgot" follow-ups.

Tip 14: Cmd+A/Ctrl+A Selects All Input Text#

Press Cmd+A (Mac) or Ctrl+A (Linux) in the input box to select all text. Useful when you want to replace an entire prompt without backspacing — just select all, type the new prompt. Faster than holding delete for 10 seconds on a long prompt that went wrong.

---

Custom Status Line#

Tip 15: Set Up a Custom Status Line Showing Model, Directory, Git Branch, and Token Usage#

A well-configured status line gives you situational awareness at a glance. Configure it to show: current model (so you know if you're on Sonnet or Opus), working directory, git branch (so you don't edit the wrong branch), and a token usage bar (so you know when to /clear). This is the dashboard your Claude Code session deserves.

Tip 16: Use /statusline to Configure#

Run /statusline to open the status line configuration. You can set which fields appear and in what order. Keep it minimal — too much information is worse than none. Model + branch + token bar is the power-user default.

---

Autonomous Work Patterns#

Tip 17: Give Claude a Verification Loop (The Git Bisect Pattern)#

Autonomous Claude without verification is a random walk. Always give it a way to check its own work: a test suite to run, a linter to pass, a build to succeed, or a git bisect to narrow down a bug. When Claude can verify, it self-corrects. When it can't, it spirals. The prompt pattern: "Make changes, run the tests, fix failures, repeat until all tests pass."

Tip 18: Use tmux for Running Claude Autonomously in Background#

Launch Claude inside a tmux session so it survives terminal disconnects:

tmux new -s claude-work
claude --permission-mode auto --max-turns 50 "Fix all failing tests in the auth module"
# Detach with Ctrl+B, D
# Reattach later: tmux attach -t claude-work

This is essential for long autonomous runs — your SSH session drops, your laptop sleeps, Claude keeps working inside tmux.

Tip 19: Use --max-turns to Limit Autonomous Runs#

Always set --max-turns when running Claude autonomously. Without it, a runaway session can burn hundreds of dollars in API costs while stuck in a loop. Set --max-turns 50 as a reasonable default for most tasks. If Claude finishes early, it exits. If it hits the limit, it stops gracefully. You can always resume with a higher limit.

---

Output Extraction#

Tip 20: /copy Copies Last Response as Markdown#

Run /copy to grab Claude's last response to your clipboard as formatted markdown. Pipe it anywhere: claude -p "explain this function" | pbcopy on macOS, or | xclip -selection clipboard on Linux. Useful for pasting into docs, PR descriptions, or Slack.

Tip 21: Write to File + Open in VS Code for Formatted Output#

When you need nicely formatted output (tables, code blocks with syntax highlighting, structured documents), ask Claude to write the result to a markdown file and open it in VS Code's Markdown Preview:

Write the comparison table to /tmp/comparison.md, then open it in VS Code with Markdown Preview.

The terminal is great for iteration; Markdown Preview is great for reading.

---

Terminal Setup#

Tip 22: Set Up Aliases for Fast Launch#

Add these to your shell config:

alias c='claude'
alias cc='claude -c'        # continue last session
alias cn='claude -n'        # named session (combine with name)

You'll launch Claude dozens of times a day. Two keystrokes instead of five compounds fast.

Tip 23: Use tmux for Long-Running Sessions That Survive Disconnects#

This overlaps with Tip 18 but deserves its own callout for interactive use: always run Claude in tmux, not just for autonomous runs. Network drops, laptop lids close, terminals crash. tmux keeps your session alive and your context intact. Reattach and you're exactly where you left off — no lost prompts, no rebuilt context.

---

Session Management#

Tip 24: Name Sessions with -n for Easy Resume#

Use the -n flag to give sessions human-readable names:

claude -n 'auth-refactor'

Later, resume by name instead of hunting through session IDs:

claude --resume 'auth-refactor'

Named sessions are searchable, memorable, and self-documenting. Use them for every non-trivial task.

Tip 25: Fork Sessions When Resuming to Preserve Original#

When you resume a session, use --fork-session to create a branch instead of overwriting:

claude --resume abc123 --fork-session

This preserves the original session's history intact. The fork starts with the same context but diverges from there. Use it when you want to try a different approach without losing the first one — like git branches for your conversation history.