The Sonnet 5.5 Prompting Guide

Mastering Effective, Efficient, and Reliable Prompting for Claude Sonnet 5.5

Introduction: Why Sonnet 5.5 Deserves Its Own Prompting Guide

1. The problem with generic prompt advice
2. What this book covers
3. What this book is not
4. How to use this book
5. A note on versions and change

Chapter 1: Why Sonnet 5.5 Is Different

1. What “Sonnet 5.5” means: the model family and its positioning
2. Key behavioral changes compared to earlier Claude versions
3. What “prompting” actually controls versus what API configuration controls
4. Why generic prompt-engineering advice often misses the mark
5. How this book is structured for progressive mastery

Chapter 2: The Prompting Landscape: Instructions, Configuration, and Safeguards

1. The dual levers: what you write in the prompt versus what you set in the API call
2. Effort levels: what they are, what they control, and how to choose
3. Thinking configuration: upfront thinking versus between_tools and adaptive reasoning
4. Token budgets and max_tokens as design decisions
5. Where application-level safeguards matter more than prompt instructions
6. Summary

Chapter 3: Reading the Official Documentation: What Anthropic Says About Sonnet 5.5

1. The “Prompting Claude Sonnet 5.5” document: structure and intent
2. Categories of official guidance: documented behavior, recommendations, observations, beta features
3. How to interpret empirical claims from the documentation
4. Where the documentation is silent and what that means
5. Navigating version-specific and evolving behavior
6. Summary

Chapter 4: The Anatomy of an Effective Prompt

1. Role and context: when it helps, when it is noise
2. Objectives and success criteria: stating what “good” looks like
3. Task decomposition: breaking complex work into model-friendly units
4. Constraints and priorities: guiding tradeoffs without overconstraining
5. Input organization: structuring information for clarity and retrieval
6. Examples and output specifications: when they are essential versus optional
7. Evaluation criteria: giving the model a standard for self-checking
8. Stopping conditions: telling Claude when it is done
9. Summary

Chapter 5: Concise Versus Detailed: Finding the Right Level of Instruction

1. The cost of verbosity: token overhead, attention dilution, and contradictory instructions
2. The cost of brevity: ambiguity, missed constraints, and inconsistent output
3. When concise prompts succeed: routine tasks, constrained domains, expert users
4. When detailed prompts are necessary: novel tasks, ambiguous domains, production reliability
5. How to compress prompts without losing essential guidance
6. Testing prompt length as a variable
7. Summary

Chapter 6: Ambiguity, Conflicting Requirements, and Robustness

1. Why ambiguous prompts produce unreliable results
2. Resolving conflicting requirements: prioritization strategies
3. Explicit ambiguity-handling instructions: what to do when unsure
4. Designing for changing inputs: prompts that adapt rather than break
5. Failure recovery: asking the model to flag problems instead of hallucinating solutions
6. Summary

Chapter 7: Effort Calibration: Quality, Latency, Cost, and the Tradeoff Triangle

1. What “effort” means for Sonnet 5.5: official definition and practical effects
2. Low effort: when to use it, what you gain, what you risk
3. Medium effort: the default operating point for agentic work
4. High effort: the API default for excellent results
5. Xhigh and Max: complex reasoning, high-stakes tasks, and when it earns its cost
6. Measuring the impact: quality vs latency vs token usage vs cost
7. How prompt complexity interacts with effort levels
8. Decision framework: choosing the right effort for your task
9. Summary

Chapter 8: Steering Initiative and Scope: Controlling How Far Claude Goes

1. The initiative problem: why Claude adds extra steps, explanations, and recommendations
2. When extra initiative is valuable and when it is wasteful
3. Explicit scope-limiting instructions: patterns that work
4. Preventing unnecessary additions: concise task-bounding language
5. Handling open-ended requests: when broadness is a feature versus a bug
6. User-facing progress updates: prompting Claude to report back during long tasks
7. Controlling follow-up questions and clarifications
8. Summary

Chapter 9: Thinking Configuration: Adaptive Reasoning and Strategic Depth

1. The three modes: upfront thinking, between_tools, and adaptive thinking
2. When upfront thinking helps: complex reasoning before action
3. When between_tools helps: iterative planning during tool use
4. When adaptive thinking helps: letting the model choose
5. Reasoning tasks that produce structured output: special considerations
6. How thinking affects latency, token cost, and output quality
7. Common misconceptions about thinking and “smarter” responses
8. Reading responses by block type
9. Summary

Chapter 10: Structured Outputs and JSON Reliability

1. Why structured output matters for production workflows
2. Prompt-level techniques: schema specification, examples, and constraints
3. API-level structured outputs: the dedicated feature and how it differs from prompting
4. JSON reliability: factors that improve or degrade format adherence
5. Handling schema violations: tolerance, error recovery, and retries
6. Complex schemas: nested objects, arrays, unions, and optional fields
7. When to use structured outputs versus parsing free-form responses
8. Summary

Chapter 11: Tool Use, Research, and Current Information

1. How tool use integrates with prompting: definitions, instructions, and constraints
2. Tool use for research: prompting Claude to gather and synthesize current information
3. Prompting for appropriate tool selection: avoiding overuse and underuse
4. Tolerant tool-call handling: parsing errors, retries, and fallback behavior
5. Long-running agentic workflows: structuring multi-step tool interactions
6. Combining tool results with reasoning: synthesis and verification patterns
7. Summary

Chapter 12: Visual Inputs: Charts, Diagrams, and Technical Drawings

1. What kinds of visual inputs Sonnet 5.5 handles well
2. Prompting for chart and graph analysis: reading values, trends, and patterns
3. Technical drawings and schematics: structured extraction from diagrams
4. Combining visual and textual prompts: coordinated instructions
5. Limitations and failure modes with complex visuals
6. Crop tool: improving accuracy on dense charts and drawings
7. Summary

Chapter 13: Long-Context Tasks and Massive Inputs

1. Context window capabilities and practical limits
2. Organizing large inputs: summaries, indexes, and structured access
3. Prompting strategies that degrade with context length and alternatives
4. Multi-pass processing: chunking, summarizing, and integrating
5. Maintaining coherence across long conversations
6. When long context helps and when smaller focused contexts work better
7. Summary

Chapter 14: Research, Writing, and Content Workflows

1. Research prompts: scoping, sourcing, synthesizing, and citing
2. Writing prompts: drafting, voice, structure, and completeness
3. Editing prompts: critique, revision, tone adjustment, and style enforcement
4. Summarization: faithful compression without loss of meaning
5. Analysis prompts: comparing sources, extracting insights, and drawing conclusions
6. Chain-of-prompts for complex content projects
7. Summary

Chapter 15: Coding, Debugging, and Software Engineering

1. Coding task scoping: when to be specific and when to trust the model
2. Debugging prompts: providing context, error messages, and expected behavior
3. Software engineering: architecture, refactoring, and design review
4. Verification requirements: testing, edge cases, and self-check patterns
5. Incremental development: building codebase changes step by step
6. When additional tools or human review are non-negotiable
7. Summary

Chapter 16: Data Extraction and Document Processing

1. Field extraction: schemas, mappings, and handling ambiguity
2. Document classification and categorization
3. Entity recognition and relationship extraction
4. Dealing with poor-quality, noisy, or inconsistent source documents
5. Batch processing patterns and maintaining consistency
6. Validation and spot-checking strategies
7. Summary

Chapter 17: Planning, Agentic Workflows, and Multi-Step Tasks

1. Task planning: prompting Claude to generate executable plans
2. Step-by-step execution: maintaining state and progress
3. Agentic loops: when Claude should decide what to do next
4. Mid-turn user messages: handling interruptions and new information
5. Error recovery in long workflows: backtracking and correction
6. Designing workflows that are robust to individual step failures
7. Summary

Chapter 18: Prompt Injection, Safety, and Refusals

1. Prompt injection fundamentals: what it is and how it works
2. System prompt versus user message: trust boundaries
3. Mid-turn prompt-injection considerations with user messages during long tasks
4. Tool-result handling: why untrusted data needs sanitization
5. Refusal behavior: categories, triggers, and workarounds (where legitimate)
6. Reasoning-extraction requests: what is possible and what is restricted
7. When application-level safeguards are required beyond prompts
8. Summary

Chapter 19: Reliability Engineering: Making Prompts Production-Ready

1. What “reliable” means for LLM prompts: consistency, correctness, and recoverability
2. Versioning prompts: tracking changes and impact
3. A/B testing prompts: comparing quality and efficiency
4. Monitoring output quality: metrics and alerting
5. Handling model updates: when behavior changes and how to adapt
6. Building fallback strategies for when prompts fail
7. Summary

Chapter 20: Prompt Optimization: Improving Without Bloating

1. Diagnose-first optimization: identifying the real bottleneck
2. Reducing instruction overhead: compression techniques
3. Improving accuracy without adding tokens
4. Latency optimization: prompt structure, effort, and thinking choices
5. Cost optimization: token efficiency across the request-response cycle
6. When to stop optimizing: diminishing returns and engineering judgment
7. Summary

Chapter 21: Common Failures and Anti-Patterns

1. Over-instructing: the paradox of too many rules
2. Under-scoping: open-ended prompts that run too far
3. Ambiguous success criteria: when “good” means nothing
4. Assuming capabilities: expecting what the model cannot reliably do
5. Ignoring effort and thinking configuration
6. Treating prompts as static: neglecting iteration and testing
7. Confusing prompt-level fixes with system-level requirements
8. Summary

Chapter 22: Comparative Strategies: Matching Approach to Task Type

1. Simple requests: minimal instruction, low effort, no thinking
2. Reasoning-intensive tasks: structured thinking, higher effort, verification
3. Coding tasks: context-rich, verification-aware, incremental
4. Research tasks: tool-heavy, iterative, synthesis-focused
5. Agentic workflows: stateful, adaptive, robust to failure
6. Structured JSON generation: schema-driven, validation-heavy
7. Multimodal tasks: coordinated visual and textual instructions
8. Decision guide: matching approach to task
9. Summary

Chapter 23: Principles, Patterns, and What Comes Next

1. Core principles of effective Sonnet 5.5 prompting
2. The most impactful patterns reviewed
3. What prompting practice will look like as models evolve
4. Staying current: monitoring Anthropic documentation and platform changes
5. Final thoughts on treating LLMs as collaborative tools, not oracles

Conclusion: The Craft of Prompting

1. From novice to practitioner: the journey mapped
2. What makes a great prompter: skills and mindset
3. The enduring value of understanding how the model works

References