Prompting Best Practices with Claude Code

Claude Code is a powerful tool, but every interaction consumes tokens. Poor usage habits can quickly blow up your consumption while degrading response quality. The good news? A few simple habits can cut your consumption by 2x or 3x.

This article presents essential practices for optimizing your daily Claude Code usage: context management, MCP configuration, and effective prompting patterns.

Understanding context and its impact

Why context blows up your consumption

With every message you send, Claude Code transmits the entire conversation to the model. This means a long session consumes exponentially more tokens.

You pay for your history with every request. This is trap number one.

The golden rule: One session = One topic

Never mix multiple topics in the same session. Each context switch should trigger a fresh, clean session.

[40-message session]
- Messages 1-15: Backend debugging
- Messages 16-25: React styling
- Messages 26-30: nginx config
- Messages 31-40: Documentation

[Session 1] Backend debugging → /clear
[Session 2] React styling → /clear
[Session 3] nginx config → /clear
[Session 4] Documentation

Mastering essential commands

The /clear command

Purpose: Completely erases conversation history.

When to use it:

• You're switching topics entirely
• You've completed a task or feature
• The conversation exceeds 20-30 messages
• You're moving from one technical domain to another (backend → frontend, code → infra)

Just fixed a bug → /clear
Switching from Python to JavaScript → /clear
Finished a code review → /clear
Session exceeded 25 messages → /clear

Important: Don't fear losing context. If you need information from the previous session, summarize it in one sentence in your new session.

The /compact command

Purpose: Summarizes the conversation while keeping only essential information.

When to use it:

• You've been working on the same topic for 15-20 messages
• Lots of debugging back-and-forth on the same issue
• The conversation contains verbose outputs (logs, SQL dumps)
• You want to continue on the same topic but lighten the context

The /context command

Purpose: Displays current context content sent to Claude.

Why it's crucial: It's your consumption dashboard. This command shows you EXACTLY what's being sent with each request.

=== Current Context ===
- History: 18 messages (approximately 12000 tokens)
- Files read: 3 files (approximately 2000 tokens)
- Active MCPs: filesystem, playwright, postgres (approximately 2500 tokens)
- System context: 1000 tokens
ESTIMATED TOTAL: 17500 tokens

Action based on result:

• Less than 5000 tokens → OK, continue
• Between 5000 and 15000 tokens → Consider /compact
• More than 15000 tokens → Run /clear or /compact

Being concise and structured

Principle: No chit-chat

Claude doesn't need pleasantries or narrative context. Get to the point.

Hey Claude! Hope you're doing well.
So here's the thing, I've got a
little issue with my code. Yesterday
I tried to do something but it
didn't work. I think it might be
related to the database...

Bug: random timeouts GET /api/users
Stack: Flask + PostgreSQL + Redis
File: src/api/users.py
Diagnose the cause.

Savings: 75% fewer tokens, clearer information.

Pattern: Structured requests

Organize complex requests into clear sections:

CONTEXT: [1 sentence]
PROBLEM: [1-2 sentences]
GOAL: [what you want]
CONSTRAINTS: [if relevant]

Real example:

CONTEXT: Flask API in production, 200 req/min
PROBLEM: 15% of POST /orders requests fail with "connection pool exhausted"
GOAL: Identify and fix DB connection leak
CONSTRAINTS: No downtime possible

File to audit: src/api/orders.py

Group requests together

Anticipate and group related requests into a single instruction.

You: Create validate_email
Claude: [creates]
You: Check format
Claude: [adds]
You: And allowed domains
Claude: [adds]
You: And log errors
Claude: [adds]

Create validate_email() that:
- Validates RFC 5322 format
- Accepts only @company.com
- Logs invalid attempts
- Returns bool
- Includes 5 unit tests

Optimizing MCP configuration

Understanding MCP impact

Each active MCP (Model Context Protocol) adds its complete documentation to the context of EVERY request, even if you don't use it.

Rule: Disable by default, enable as needed

Most of the time, you only need 1 or 2 MCPs maximum.

How to disable MCPs

Open your configuration file (~/.config/claude/settings.json) and add "disabled": true:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-playwright"],
      "disabled": true
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "disabled": true
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem"],
      "disabled": false
    }
  }
}

Tip: Create multiple versions of this file for different needs:

• settings-minimal.json: Only filesystem
• settings-backend.json: filesystem + postgres
• settings-frontend.json: filesystem + playwright

To launch Claude Code with a specific configuration, use the --mcp-config option:

# Launch with minimal config
claude --mcp-config ~/.config/claude/settings-minimal.json

# Launch for backend work
claude --mcp-config ~/.config/claude/settings-backend.json

# Create aliases in your .bashrc or .zshrc
alias claude-mini="claude --mcp-config ~/.config/claude/settings-minimal.json"
alias claude-back="claude --mcp-config ~/.config/claude/settings-backend.json"
alias claude-front="claude --mcp-config ~/.config/claude/settings-frontend.json"

Advanced prompting patterns

Pattern: Instructions without explanation

By default, Claude likes to explain what it's doing. It's educational but costly.

You: Create a validation function
Claude: I'll create a function
that validates passwords according
to standard security criteria.
It will check minimum length,
presence of special characters...
[code]

You: Create a validation function.
Code only, no explanation.

Claude: [code directly]

Always add "code only" or "direct action" when you don't need explanations.

Pattern: Targeted file reading

Don't read entire files if you only need a section.

You: Read src/api/users.py (500 lines)
Claude: [reads everything]
You: Just look at get_user_by_id

You: Read only the function
get_user_by_id in src/api/users.py

Pattern: Direct commands

For simple actions, request the action directly without preamble.

You: Could you please run the
unit tests to see if there are
any errors?

You: pytest

For standard bash actions, be minimalist:

• pytest instead of "run the tests"
• git status instead of "check the repo state"
• ls src/ instead of "show me the files in src"

Session management and workflows

Workflow: Complete feature

[Single 2-hour session with 50 messages]
- Brainstorming
- Iterative implementation
- Tests
- Documentation
- Fixes

[Session 1 - Planning] 10 msg → /clear
[Session 2 - Implementation] 15 msg → /clear
[Session 3 - Tests] 8 msg → /clear
[Session 4 - Docs] 5 msg

Workflow: Debugging

Debugging tends to blow up context with logs and stack traces.

3-phase strategy:

PHASE 1 - Diagnosis (short session)
You: Bug on POST /orders: timeouts
Logs: [20 relevant lines]
Code: src/api/orders.py
Diagnose the probable cause.
Claude: Probable cause: connection pool leak line 45
You: /clear

PHASE 2 - Fix (new session)
You: Fix the connection pool leak in src/api/orders.py line 45
Claude: [fixes]
You: /clear

PHASE 3 - Validation (new session)
You: pytest tests/test_orders.py
Claude: [runs tests]

Session checklist

Common mistakes to avoid

Mistake 1: The marathon session

Symptom: A session that lasts hours with 60+ messages on various topics.

Impact: Consuming 50000+ tokens when 10000 would have sufficed.

Solution: Set a limit of 25 messages per session.

Mistake 2: All MCPs enabled by default

Symptom: You've never touched your settings.json.

Impact: 2000-3000 token "tax" per message.

Solution: Disable everything except filesystem, enable on a case-by-case basis.

Mistake 3: Reading entire large files

Symptom: "Read src/main.py" when the file is 1000 lines.

Impact: 1000+ tokens consumed unnecessarily.

Solution: Use grep or request targeted reads.

Mistake 4: Asking for systematic explanations

Symptom: Claude explains at length before each action.

Impact: 40-60% more tokens.

Solution: Add "code only, no explanation".

Mistake 5: Never using /context

Symptom: You don't know how many tokens your session is consuming.

Impact: You're navigating blind.

Solution: Type /context every 10-15 messages.

Conclusion

Optimizing your Claude Code usage means adopting simple habits:

1. One session = One topic: /clear between each context switch
2. Less than 25 messages per session: Beyond that, /compact or /clear
3. Check context regularly: /context every 10-15 messages
4. Disable unused MCPs: Only filesystem is needed 80% of the time
5. Be concise and structured: No chit-chat, grouped information
6. Direct action: "Code only" when you don't need explanations

Start with just one habit: type /context before your big requests. You'll immediately see your context's impact. Then gradually add the other practices.