Official Claude Prompting: Everything You Need To Know

What Anthropic's official prompting guide says - plus the stuff between the lines

You’re using Claude Opus 4.5 or Sonnet 4.5. You type prompts. You get responses. Sometimes great. Sometimes weird. Sometimes the model does things you didn’t ask for. Sometimes it refuses to do things it should handle fine.

Here’s the thing: Anthropic published an entire guide on how to prompt Claude 4.x models differently. Most people never read it.

I did.

Here’s what actually matters - plus a few things they don’t explicitly tell you.

---

The Core Principle: Claude 4.x Is Literal

Claude 4.x models were trained for precise instruction following. This sounds good until you realize what it means in practice:

If you say “suggest some changes,” Claude will suggest. Not implement. Suggest.

If you want changes made, you need to say “make these changes” or “implement this.”

From the official guide: “If you say ‘can you suggest some changes,’ it will sometimes provide suggestions rather than implementing them—even if making changes might be what you intended.”

The model is smart. It’s also literal. Your prompts need to match.

---

Setting Default Behaviors

Want Claude to be proactive by default? Add this to your system prompt:

<default_to_action>

By default, implement changes rather than only suggesting them. If the user’s intent is unclear, infer the most useful likely action and proceed, using tools to discover any missing details instead of guessing.

</default_to_action>

Want Claude to be conservative and wait for explicit instructions?

<do_not_act_before_instructions>

Do not jump into implementation or change files unless clearly instructed to make changes. When the user’s intent is ambiguous, default to providing information, doing research, and providing recommendations rather than taking action.

</do_not_act_before_instructions>

Pick one. Be explicit. The model will follow.

---

Context Changes Everything

This is the part most people skip.

Less effective:

NEVER use ellipses

More effective:

Your response will be read aloud by a text-to-speech engine, so never use ellipses since the text-to-speech engine will not know how to pronounce them.

The guide says: “Providing context or motivation behind your instructions, such as explaining to Claude why such behavior is important, can help Claude 4.x models better understand your goals and deliver more targeted responses.”

Claude is smart enough to generalize from the explanation. Tell it *why*, not just *what*.

---

The Verbosity Trap

Claude 4.5 is more concise by default. It provides “fact-based progress reports rather than self-celebratory updates.” It may skip detailed summaries for efficiency.

The problem: If you want visibility into what it’s doing, you need to ask.

After completing a task that involves tool use, provide a quick summary of the work you’ve done.

Without this, Claude will just... do the work and move on. Quietly. Efficiently. Without telling you what happened.

---

Long Tasks: State Management

This is where Claude 4.5 shines - if you set it up right.

For tasks spanning multiple context windows:

1. Use structured formats for state:

JSON:

{ “tests”: [     {”id”: 1, “name”: “authentication_flow”, “status”: “passing”},    {”id”: 2, “name”: “user_management”, “status”: “failing”},    {”id”: 3, “name”: “api_endpoints”, “status”: “not_started”}  ],
“total”: 200,
“passing”: 150,
“failing”: 25
}

2. Use freeform text for progress notes:

Session 3 progress:
- Fixed authentication token validation
- Updated user model to handle edge cases
- Next: investigate user_management test failures

3. Use git for state tracking. The guide explicitly says: “Claude 4.5 models perform especially well in using git to track state across multiple sessions.”

4. Start fresh instead of compacting. Here’s something most people don’t know: “When a context window is cleared, consider starting with a brand new context window rather than using compaction. Claude 4.5 models are extremely effective at discovering state from the local filesystem.”

Don’t waste time trying to preserve context. Let the model discover state from your files. It’s better at this than you think.

---

Tool Usage: Dial Back the Aggression

If you’ve been using aggressive language like “CRITICAL: You MUST use this tool when...”, Claude 4.5 will overtrigger.

The guide says: “Claude Opus 4.5 is more responsive to the system prompt than previous models. If your prompts were designed to reduce undertriggering on tools or skills, Claude Opus 4.5 may now overtrigger.”

The fix: Use normal prompting. “Use this tool when...” instead of “CRITICAL: You MUST use this tool when...”

---

Parallel Tool Calling

Claude 4.x models are aggressive about parallelization. Sonnet 4.5 especially. It will:

- Run multiple searches during research

- Read several files at once

- Execute bash commands in parallel (which can bottleneck your system)

To maximize this:

<use_parallel_tool_calls>

If you intend to call multiple tools and there are no dependencies between the tool calls, make all of the independent tool calls in parallel. Maximize use of parallel tool calls where possible to increase speed and efficiency.

</use_parallel_tool_calls>

To reduce it:

Execute operations sequentially with brief pauses between each step to ensure stability.

---

The Overengineering Problem

Claude Opus 4.5 tends to overengineer. It creates extra files, adds unnecessary abstractions, builds in flexibility you didn’t ask for.

If you’re seeing this:

Avoid over-engineering. Only make changes that are directly requested or clearly necessary. Keep solutions simple and focused.

Don’t add features, refactor code, or make “improvements” beyond what was asked. A bug fix doesn’t need surrounding code cleaned up. A simple feature doesn’t need extra configurability.

Don’t create helpers, utilities, or abstractions for one-time operations. Don’t design for hypothetical future requirements. The right amount of complexity is the minimum needed for the current task.

---

Code Exploration: Force It to Look

Claude Opus 4.5 can be overly conservative when exploring code. It might propose solutions without actually reading the files.

Fix this explicitly:

ALWAYS read and understand relevant files before proposing code edits. Do not speculate about code you have not inspected. If the user references a specific file/path, you MUST open and inspect it before explaining or proposing fixes.

---

The “Think” Problem

When extended thinking is disabled, Claude Opus 4.5 is sensitive to the word “think.”

Replace “think” with:

- “consider”

- “evaluate”

- “assess”

- “analyze”

Small change. Noticeable difference.

---

Research: Structure It

For complex research tasks:

Search for this information in a structured way. As you gather data, develop several competing hypotheses. Track your confidence levels in your progress notes. Regularly self-critique your approach and plan. Update a hypothesis tree or research notes file to persist information.

This structured approach lets Claude find and synthesize information iteratively, critiquing its own findings as it goes.

---

“Stuff” Between The Lines (That You Should Know)

1. Examples matter more than instructions.

The guide says Claude 4.x models “pay close attention to details and examples.” This means: if your examples show a behavior, Claude will replicate it—even if your instructions say otherwise. Audit your examples.

2. Formatting begets formatting.

The style of your prompt influences Claude’s response. If you want less markdown in outputs, remove markdown from your prompt. The guide notes: “removing markdown from your prompt can reduce the volume of markdown in the output.”

3. Tell it what TO do, not what NOT to do.

Instead of: “Do not use markdown in your response”

Try: “Your response should be composed of smoothly flowing prose paragraphs.”

Positive instructions work better than negative ones.

4. Subagent orchestration is automatic.

Claude 4.5 models “can recognize when tasks would benefit from delegating work to specialized subagents and do so proactively without requiring explicit instruction.” You don’t need to tell it to delegate—it will figure that out.

5. Context awareness is built in.

Claude 4.5 tracks its remaining context window. It knows when it’s running out of space. You can leverage this:

Your context window will be automatically compacted as it approaches its limit, allowing you to continue working indefinitely. Do not stop tasks early due to token budget concerns. As you approach your token budget limit, save your current progress and state to memory before the context window refreshes.

---

The Uncomfortable Truth

Most people are prompting Claude 4.5 like it’s a chatbot. It’s not. It’s a precise instruction-following system that happens to be conversational.

The gap isn’t between people using Claude and people not using it. It’s between people who read the prompting guide and people who didn’t.

Three things separate effective Claude 4.x users:

1. They set explicit defaults: Proactive or conservative, they tell Claude which to be.

2. They provide context: They explain *why*, not just *what*. Claude generalizes from motivation.

3. They use state management: For long tasks, they leverage structured formats, git, and fresh context windows instead of fighting token limits.

---

Next Steps

1. Audit your system prompts: Look for implicit expectations. Make them explicit. Add `<default_to_action>` or `<do_not_act_before_instructions>` based on what you actually want.

2. Add context to instructions: Before giving a task, explain why it matters. One sentence changes how Claude approaches the problem.

3. Dial back aggressive language: Replace “CRITICAL” and “MUST” with normal instructions. Claude 4.5 doesn’t need shouting.

4. Set up state tracking: For complex tasks, use JSON for structured data, text for progress notes, git for history.

5. Replace “think” with alternatives: Use “consider,” “evaluate,” “assess” when extended thinking is off.

6. Request verbosity explicitly: If you want Claude to explain what it’s doing, ask. It won’t volunteer.

---

The official guide is at [platform.claude.com/docs](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-4-best-practices). It’s worth reading.

But now you have the highlights - plus the stuff between the lines.

Your prompts are instructions. Claude 4.x follows instructions precisely. The better your instructions, the better your results.

Most people won’t update their prompting. You will.