Who This Guide Is For
You have Claude Code installed and running. You have used it to write a function, fix a bug, or scaffold a file. Now you want to use it better: with more control, less waste, and more capability.
This guide covers five features that most developers discover weeks in. Learn them now and you will avoid the frustration of runaway token sessions, surprise rewrites, and hitting walls that plugins already solve.
Plan Mode: Review Before Claude Touches Anything
Plan Mode is the single most useful safety feature in Claude Code. When enabled, Claude describes every step it plans to take before executing a single action. No files are created, edited, or deleted until you approve.
Why Plan Mode matters
You catch misaligned assumptions early. Claude sometimes interprets an ambiguous request differently from what you intended. Plan Mode surfaces that mismatch in a ten-second read rather than a ten-minute rollback.
You maintain architectural control. When Claude proposes creating a new file or adding a dependency, you see it upfront. You can redirect the approach before it propagates through three other files.
You avoid irreversible changes to shared code. On production branches or files used by multiple systems, reviewing the plan before execution is the same discipline as reviewing a pull request before merging.
How to toggle Plan Mode
Press Shift+Tab during any Claude Code session to cycle through permission modes:
| Mode |
Behavior |
| Default |
Claude asks permission before each tool use |
| Auto-approve |
Claude runs actions without per-step prompts |
| Plan Mode |
Claude outputs a plan; no actions execute until you confirm |
Shift+Tab cycles through these modes in order. The current mode is shown in the Claude Code status line.
Recommended workflow
- Start a new task and press Shift+Tab until Plan Mode is active.
- Describe what you want. Claude outputs a numbered plan.
- Read the plan. If an assumption looks wrong, correct it in plain English: "Skip creating a new file; modify the existing one in
src/utils/."
- Confirm. Claude executes the approved steps.
- For routine tasks you trust, toggle back to Default or Auto-approve.
Plan Mode adds about thirty seconds to a task start. It prevents hours of cleanup on misunderstood requirements.
/usage: Know What Your Session Is Costing
Token consumption in a long Claude Code session compounds faster than most developers expect. The /usage command gives you a live breakdown.
What /usage shows
Run /usage at any point in a session and Claude returns:
- Input tokens used in the current session
- Output tokens generated
- Cache read and write counts (cache hits dramatically reduce cost)
- Estimated cost based on the model currently in use
When to run it
Run /usage after any session that involved reading large files, processing long outputs, or iterating on a complex task. If your session cost exceeds what you expected for the work done, that is a signal your context has grown inefficient. The next section explains how to fix that.
Keeping Context Small: Five Practical Habits
Claude Code performance degrades as context grows. Larger context means slower responses, higher token cost, and a higher risk that relevant information gets lost in noise. These five habits keep sessions tight.
1. Use /clear to reset between unrelated tasks
/clear wipes the current conversation history and starts a fresh context. When you finish one task and move to a different part of the codebase, run /clear before starting the next request. The session cost resets and Claude does not carry irrelevant context forward.
2. Reference files by path, not by pasting content
Instead of pasting three hundred lines of code into your prompt, say: "Look at src/api/auth.ts and add input validation to the loginUser function." Claude reads the file directly. This uses a fraction of the tokens that a full paste would consume.
3. Avoid uploading content that Claude does not need
Large log files, full database dumps, and entire dependency trees are common context killers. If you are debugging one function, give Claude only that function and its direct dependencies. Specificity is cheaper.
4. Break large tasks into sequential sessions
Trying to complete an entire feature in one session accumulates context from every intermediate step. Instead, complete one logical piece, commit the result, run /clear, and start the next piece with a clean context. The commits also serve as natural checkpoints.
5. Use /compact to summarize without losing history
/compact compresses the current conversation into a concise summary while preserving the key facts Claude needs. Use it when you need continuity across a long session but want to reduce token overhead. Think of it as a lossy checkpoint: faster and cheaper than continuing with the full raw history, but retaining enough context to keep working.
Combining /clear on unrelated tasks with /compact on long continuous tasks typically reduces context bloat by sixty to eighty percent.
/context: Inspect What Claude Is Actually Seeing
Before debugging a slow or confused response, run /context to see exactly what is in the active context window.
What /context shows
- All files currently attached or referenced
- System prompts and CLAUDE.md instructions active in this session
- Any memory files loaded
- The total context size in tokens
Why this is useful for diagnosis
If Claude gives an answer that seems to ignore something you told it earlier, /context often reveals why: the relevant exchange was compressed or truncated. You can then re-supply the critical information explicitly.
If a session feels sluggish, /context shows whether an unexpectedly large file was loaded. You can remove it and restart with a scoped reference instead.
/context is also useful when onboarding to a shared Claude Code setup. It makes visible what instructions and files are shaping Claude's behavior for that project, which is often stored in a CLAUDE.md file the new developer has not read yet.
Plugins: Extend Claude Code with Specialized Capabilities
Plugins add skills, agents, slash commands, and hooks to Claude Code without modifying the core tool. They are the primary extension mechanism for teams that want to standardize workflows across developers.
What plugins provide
A plugin can include:
- Skills: Reusable prompt templates that teach Claude how to do a specific task (for example, reviewing a pull request against your team's standards)
- Agents: Specialized subagents with their own system prompts and tool access, launched for defined subtasks
- Slash commands: Custom
/commands that execute a scripted sequence of actions
- Hooks: Event-driven scripts that run automatically on actions like file saves, test runs, or session end
Plugin catalog
The following plugins are available and actively maintained:
| Plugin |
What It Does |
| pr-review-toolkit |
Comprehensive pull request review: code quality, test coverage, type design, silent failure detection, and comment accuracy |
| feature-dev |
Guided feature development with codebase exploration, architecture design, and code review agents |
| code-simplifier |
Refines recently written code for clarity and maintainability without changing behavior |
| commit-commands |
Structured git commits, commit-push-PR workflows, and gone-branch cleanup |
| claude-md-management |
Audits and improves CLAUDE.md files; captures session learnings into project memory |
| claude-code-setup |
Analyzes a codebase and recommends Claude Code automations (hooks, agents, MCP servers) |
| agent-sdk-dev |
Verifies TypeScript and Python Agent SDK applications against best practices |
| plugin-dev |
End-to-end plugin creation: structure, commands, agents, skills, hooks, MCP integration, and settings |
| skill-creator |
Creates new skills, benchmarks performance, and optimizes skill trigger descriptions |
| frontend-design |
Generates production-grade frontend components with high design quality |
| data |
Airflow DAG authoring, dbt/Cosmos integration, warehouse lineage tracing, data profiling, and HITL workflows |
| claude-api |
Builds applications using the Claude API and Anthropic SDK |
| statusline-setup |
Configures the Claude Code status line display |
| keybindings-help |
Customizes keyboard shortcuts and chord bindings |
Installing a plugin
Plugins are installed by adding them to your Claude Code settings. The plugin-dev:plugin-structure skill provides the exact configuration steps. Once installed, the plugin's skills appear in Claude's available skill set and its slash commands appear in the / command list.
When to reach for a plugin instead of a prompt
A plugin is worth installing when you repeat the same type of work across sessions. Code review checklists, commit message formatting, DAG testing workflows, and PR analysis are all examples of tasks where a plugin encodes the right process once and applies it consistently every time, without requiring you to re-specify the approach.
Quick Reference
| Feature |
How to Activate |
What It Does |
| Plan Mode |
Shift+Tab (cycle to Plan Mode) |
Claude describes all steps before executing |
| Auto-approve |
Shift+Tab (cycle to Auto-approve) |
Claude runs actions without per-step confirmation |
/usage |
Type /usage in session |
Shows token consumption and estimated cost |
/clear |
Type /clear in session |
Resets conversation history; starts fresh context |
/compact |
Type /compact in session |
Compresses history into a summary; preserves key facts |
/context |
Type /context in session |
Shows all files, instructions, and tokens in active context |
| Plugins |
Via settings configuration |
Adds skills, agents, commands, and hooks |
Next Steps
If you are setting up Claude Code for the first time on Windows, the WSL setup guide covers the full environment from scratch. If you are evaluating Claude Code against other AI developer tools for a migration or workflow decision, the Next.js migration case study shows how it performs on a real production project.
For teams looking to standardize Claude Code usage across developers, the claude-md-management and claude-code-setup plugins are the right starting point: the first captures your project's conventions into a CLAUDE.md that every developer inherits, and the second recommends automations that fit your specific codebase.
