Use this skill when you writing commands, hooks, skills for Agent, or prompts for sub agents or any other LLM interaction, including optimizing prompts, improving LLM outputs, or designing production prompt templates.

Prompt Engineering Patterns Advanced prompt engineering techniques to maximize LLM performance, reliability, and controllability. Core Capabilities 1. Few Shot Learning Teach the model by showing examples instead of explaining rules. Include 2 5 input output pairs that demonstrate the desired behavior. Use when you need consistent formatting, specific reasoning patterns, or handling of edge cases. More examples improve accuracy but consume tokens—balance based on task complexity. Example: 2. Chain of Thought Prompting Request step by step reasoning before the final answer. Add "Let's think step by step" (zero shot) or include example reasoning traces (few shot). Use for complex problems requiring multi step logic, mathematical reasoning, or when you need to verify the model's thought process. Improves accuracy on analytical tasks by 30 50%. Example: 3. Prompt Optimization Systematically improve prompts through testing and refinement. Start simple, measure performance (accuracy, consistency, token usage), then iterate. Test on diverse inputs including edge cases. Use A/B testing to compare variations. Critical for production prompts where consistency and cost matter. Example: 4. Template Systems Build reusable prompt structures with variables, conditional sections, and modular components. Use for multi turn conversations, role based interactions, or when the same pattern applies to different inputs. Reduces duplication and ensures consistency across similar tasks. Example: 5. System Prompt Design Set global behavior and constraints that persist across the conversation. Define the model's role, expertise level, output format, and safety guidelines. Use system prompts for stable instructions that shouldn't change turn to turn, freeing up user message tokens for variable content. Example: Key Patterns Progressive Disclosure Start with simple prompts, add complexity only when needed: 1. Level 1 : Direct instruction "Summarize this article" 2. Level 2 : Add constraints "Summarize this article in 3 bullet points, focusing on key findings" 3. Level 3 : Add reasoning "Read this article, identify the main findings, then summarize in 3 bullet points" 4. Level 4 : Add examples Include 2 3 example summaries with input output pairs Instruction Hierarchy Error Recovery Build prompts that gracefully handle failures: Include fallback instructions Request confidence scores Ask for alternative interpretations when uncertain Specify how to indicate missing information Best Practices 1. Be Specific : Vague prompts produce inconsistent results 2. Show, Don't Tell : Examples are more effective than descriptions 3. Test Extensively : Evaluate on diverse, representative inputs 4. Iterate Rapidly : Small changes can have large impacts 5. Monitor Performance : Track metrics in production 6. Version Control : Treat prompts as code with proper versioning 7. Document Intent : Explain why prompts are structured as they are Common Pitfalls Over engineering : Starting with complex prompts before trying simple ones Example pollution : Using examples that don't match the target task Context overflow : Exceeding token limits with excessive examples Ambiguous instructions : Leaving room for multiple interpretations Ignoring edge cases : Not testing on unusual or boundary inputs Integration Patterns With RAG Systems With Validation Performance Optimization Token Efficiency Remove redundant words and phrases Use abbreviations consistently after first definition Consolidate similar instructions Move stable content to system prompts Latency Reduction Minimize prompt length without sacrificing quality Use streaming for long form outputs Cache common prompt prefixes Batch similar requests when possible Agent Prompting Best Practices Based on Anthropic's official best practices for agent prompting. Core principles Context Window The “context window” refers to the entirety of the amount of text a language model can look back on and reference when generating new text plus the new text it generates. This is different from the large corpus of data the language model was trained on, and instead represents a “working memory” for the model. A larger context window allows the model to understand and respond to more complex and lengthy prompts, while a smaller context window may limit the model’s ability to handle longer prompts or maintain coherence over extended conversations. Progressive token accumulation: As the conversation advances through turns, each user message and assistant response accumulates within the context window. Previous turns are preserved completely. Linear growth pattern: The context usage grows linearly with each turn, with previous turns preserved completely. 200K token capacity: The total available context window (200,000 tokens) represents the maximum capacity for storing conversation history and generating new output from Claude. Input output flow: Each turn consists of: Input phase: Contains all previous conversation history plus the current user message Output phase: Generates a text response that becomes part of a future input Concise is key The context window is a public good. Your prompt, command, skill shares the context window with everything else Claude needs to know, including: The system prompt Conversation history Other commands, skills, hooks, metadata Your actual request Default assumption : Claude is already very smart Only add context Claude doesn't already have. Challenge each piece of information: "Does Claude really need this explanation?" "Can I assume Claude knows this?" "Does this paragraph justify its token cost?" Good example: Concise (approximately 50 tokens): python import pdfplumber with pdfplumber.open("file.pdf") as pdf: text = pdf.pages[0].extract text() Bad example: Too verbose (approximately 150 tokens): The concise version assumes Claude knows what PDFs are and how libraries work. Set appropriate degrees of freedom Match the level of specificity to the task's fragility and variability. High freedom (text based instructions): Use when: Multiple approaches are valid Decisions depend on context Heuristics guide the approach Example: Medium freedom (pseudocode or scripts with parameters): Use when: A preferred pattern exists Some variation is acceptable Configuration affects behavior Example: python def generate report(data, format="markdown", include charts=True): Process data Generate output in specified format Optionally include visualizations Low freedom (specific scripts, few or no parameters): Use when: Operations are fragile and error prone Consistency is critical A specific sequence must be followed Example: bash python scripts/migrate.py verify backup Analogy : Think of Claude as a robot exploring a path: Narrow bridge with cliffs on both sides : There's only one safe way forward. Provide specific guardrails and exact instructions (low freedom). Example: database migrations that must run in exact sequence. Open field with no hazards : Many paths lead to success. Give general direction and trust Claude to find the best route (high freedom). Example: code reviews where context determines the best approach. Persuasion Principles for Agent Communication Usefull for writing prompts, including but not limited to: commands, hooks, skills for Claude Code, or prompts for sub agents or any other LLM interaction. Overview LLMs respond to the same persuasion principles as humans. Understanding this psychology helps you design more effective skills not to manipulate, but to ensure critical practices are followed even under pressure. Research foundation: Meincke et al. (2025) tested 7 persuasion principles with N=28,000 AI conversations. Persuasion techniques more than doubled compliance rates (33% → 72%, p < .001). The Seven Principles 1. Authority What it is: Deference to expertise, credentials, or official sources. How it works in prompts: Imperative language: "YOU MUST", "Never", "Always" Non negotiable framing: "No exceptions" Eliminates decision fatigue and rationalization When to use: Discipline enforcing skills (TDD, verification requirements) Safety critical practices Established best practices Example: 2. Commitment What it is: Consistency with prior actions, statements, or public declarations. How it works in prompts: Require announcements: "Announce skill usage" Force explicit choices: "Choose A, B, or C" Use tracking: TodoWrite for checklists When to use: Ensuring skills are actually followed Multi step processes Accountability mechanisms Example: 3. Scarcity What it is: Urgency from time limits or limited availability. How it works in prompts: Time bound requirements: "Before proceeding" Sequential dependencies: "Immediately after X" Prevents procrastination When to use: Immediate verification requirements Time sensitive workflows Preventing "I'll do it later" Example: 4. Social Proof What it is: Conformity to what others do or what's considered normal. How it works in prompts: Universal patterns: "Every time", "Always" Failure modes: "X without Y = failure" Establishes norms When to use: Documenting universal practices Warning about common failures Reinforcing standards Example: 5. Unity What it is: Shared identity, "we ness", in group belonging. How it works in prompts: Collaborative language: "our codebase", "we're colleagues" Shared goals: "we both want quality" When to use: Collaborative workflows Establishing team culture Non hierarchical practices Example: 6. Reciprocity What it is: Obligation to return benefits received. How it works: Use sparingly can feel manipulative Rarely needed in prompts When to avoid: Almost always (other principles more effective) 7. Liking What it is: Preference for cooperating with those we like. How it works: DON'T USE for compliance Conflicts with honest feedback culture Creates sycophancy When to avoid: Always for discipline enforcement Principle Combinations by Prompt Type Prompt Type Use Avoid Discipline enforcing Authority + Commitment + Social Proof Liking, Reciprocity Guidance/technique Moderate Authority + Unity Heavy authority Collaborative Unity + Commitment Authority, Liking Reference Clarity only All persuasion Why This Works: The Psychology Bright line rules reduce rationalization: "YOU MUST" removes decision fatigue Absolute language eliminates "is this an exception?" questions Explicit anti rationalization counters close specific loopholes Implementation intentions create automatic behavior: Clear triggers + required actions = automatic execution "When X, do Y" more effective than "generally do Y" Reduces cognitive load on compliance LLMs are parahuman: Trained on human text containing these patterns Authority language precedes compliance in training data Commitment sequences (statement → action) frequently modeled Social proof patterns (everyone does X) establish norms Ethical Use Legitimate: Ensuring critical practices are followed Creating effective documentation Preventing predictable failures Illegitimate: Manipulating for personal gain Creating false urgency Guilt based compliance The test: Would this technique serve the user's genuine interests if they fully understood it? Quick Reference When designing a prompt, ask: 1. What type is it? (Discipline vs. guidance vs. reference) 2. What behavior am I trying to change? 3. Which principle(s)

prompt-engineering