Prompt Optimization

Prompt Optimization Skill

Overview

Transform any request into an optimized, production-ready prompt for Claude 4.x that eliminates hallucinations and ensures first-response accuracy. Apply investigation-first protocols, extended thinking patterns, and anti-hallucination guards.

When to Use

Trigger this skill when:

• User requests prompt improvement or optimization
• Prompt contains "optimize", "improve my prompt", "make this better"
• Vague requests need clarification and structure
• Existing prompts show hallucination issues
• User mentions "investigation first", "anti-hallucination", "production-ready"

Quick Start

Basic Optimization

User: "optimize: [paste prompt]"
→ Analyze structure
→ Apply Claude 4.x patterns
→ Return production version

Eliminate Hallucinations

User: "fix hallucinations in: [prompt]"
→ Add investigation protocol
→ Insert verification checkpoints
→ Remove speculation triggers

Core Optimization Framework

6 Key Strategies

1. Context & Motivation

Explain WHY, not just WHAT.

❌ WEAK: "Never use ellipses"
✅ STRONG: "Your response will be read by text-to-speech, 
so never use ellipses since TTS cannot pronounce them."

2. Investigation-First

NEVER provide answers before investigating.

<investigation_required>
When user asks: "Fix this bug"

❌ DON'T: Immediately suggest fixes
✅ DO: 
1. Examine code structure
2. Identify error location
3. Trace execution path
4. Review logs
5. Form evidence-based hypothesis
6. THEN suggest solution
</investigation_required>

3. Multishot Examples

Provide 2-3 examples covering different scenarios.

<multishot_pattern>
- Typical case (80% of scenarios)
- Edge case (unusual but valid)
- Error case (what NOT to do)
</multishot_pattern>

4. Explicit Output Format

Define EXACTLY what output should look like.

<output_format>
Structure:
1. **Summary** (2-3 sentences)
2. **Key Findings** (bullets)
3. **Recommendations** (numbered)
4. **Next Steps** (actions)

Do NOT include opinions or speculation.
</output_format>

5. Extended Thinking

For complex tasks, enable step-by-step reasoning.

<thinking_protocol>
Break down the problem:
1. What are we achieving?
2. What info do we have?
3. What steps are needed?
4. What could go wrong?
5. How do we verify?
</thinking_protocol>

6. Anti-Hallucination Guards

<anti_hallucination>
<rules>
1. NEVER make up facts/statistics
2. ALWAYS cite sources when available
3. Use "I don't know" when uncertain
4. Investigate before answering
5. Verify against context
</rules>

<when_uncertain>
If info not in context:
- State what you DO know
- Explain what's missing
- Suggest how to find it
- DON'T guess
</when_uncertain>
</anti_hallucination>

Optimized Prompt Template

Use this structure:

<role>
Specific expert role with domain knowledge
</role>

<context>
Why this task matters and background
</context>

<investigation>
What to check before responding:
- Information to gather
- Resources to consult
- Questions to clarify
</investigation>

<thinking>
Step-by-step approach:
1. Analyze request
2. Identify requirements
3. Consider edge cases
4. Plan response
5. Verify assumptions
</thinking>

<execution>
How to perform the task:
- Steps to follow
- Tools/methods to use
- Quality checks
</execution>

<output_format>
Exact format for response
</output_format>

<anti_hallucination>
Never speculate. If uncertain, state clearly.
</anti_hallucination>

<examples>
<example type="typical">[Ex 1]</example>
<example type="edge">[Ex 2]</example>
<example type="error">[Ex 3]</example>
</examples>
</optimized_prompt_template>

Claude 4.x Features

Extended Thinking

Enable for complex reasoning tasks.

<extended_thinking>
Use when task requires:
- Multi-step analysis
- Complex problem solving
- Long-horizon planning

Pattern: "Think step-by-step:
1. [Step]
2. [Step]
3. [Verification]"
</extended_thinking>

Parallel Tool Calling

Run multiple operations simultaneously.

<parallel_tools>
✅ DO: Call tools in parallel when independent
❌ DON'T: Sequential when unnecessary

Example: "Fetch user AND load settings AND check permissions"
→ All run simultaneously
</parallel_tools>

Long-Horizon Tasks

Track progress across interactions.

<long_horizon>
<state_management>
- Create progress.txt
- Log completed subtasks
- Note blockers
- Update after each step
</state_management>

<continuation>
When resuming:
1. Read progress.txt
2. Verify last state
3. Continue next task
4. Update progress
</continuation>
</long_horizon>

MCP Integration

<mcp_pattern>
<discovery>
1. Check MCP resources
2. Identify relevant tools
3. Load contextual prompts
</discovery>

<execution>
User asks about data:
1. Search MCP resources
2. Use MCP tools for real-time data
3. Apply MCP formatting prompts
4. Combine response
</execution>

<example>
"What's in Q4 sales report?"
→ MCP Resource: google_drive://Q4_Sales.xlsx
→ MCP Tool: parse_excel()
→ MCP Prompt: sales_summary_template
→ Return formatted analysis
</example>
</mcp_pattern>

Real-World Examples

Example 1: Vague → Structured

Before: "Help me build a website"

After: See website-build-example.md

Example 2: Bug Fix → Investigation-First

Before: "My app crashes on submit"

After: See bug-fix-example.md

Example 3: Data Analysis → Verification-First

Before: "Analyze this CSV"

After: See data-analysis-example.md

Advanced Patterns

Self-Verification

<self_verification>
After generating response:
1. Review vs requirements
2. Check hallucinations
3. Verify facts
4. Confirm format
5. Test edge cases

Issues found? Revise before delivery.
</self_verification>

Progressive Refinement

<progressive_refinement>
For complex prompts:
1. Start basic
2. Test samples
3. Identify failures
4. Add guards
5. Retest
6. Document

Iterate based on performance.
</progressive_refinement>

Context Management

<context_optimization>
For large prompts:
1. **Essential First**: Core instructions at top
2. **Progressive Disclosure**: Details on-demand
3. **References**: Link vs including
4. **Examples Last**: After instructions

If >2000 words:
- Split into skill + references/
- Use MCP for external resources
</context_optimization>

Guidelines

Always Do:

✅ Investigate before answering ✅ Provide multiple examples ✅ Define clear output format ✅ Include anti-hallucination guards ✅ Explain WHY, not just WHAT ✅ Use XML for structure ✅ Test with edge cases

Never Do:

❌ Skip investigation ❌ Assume intent ❌ Single example only ❌ Ambiguous output format ❌ Ignore hallucination risks ❌ Vague instructions ❌ Deliver untested prompts

Red Flags (Fix These):

🚩 "Create something" (too vague) 🚩 No examples 🚩 Missing output format 🚩 No verification steps 🚩 Assumes context 🚩 No anti-hallucination guards 🚩 Single-shot examples

Output Template

Deliver this when optimizing:

# Optimized Prompt

[Complete optimized prompt in XML format]

---

## Optimization Summary

**Changes Made:**
- Added investigation protocol
- Included multishot examples
- Defined output format
- Added anti-hallucination guards
- [Others]

**Expected Improvements:**
- Hallucination reduction: ~X%
- First-response accuracy: ~Y%
- Clarity: High/Medium/Low

**Testing Checklist:**
- [ ] Typical case
- [ ] Edge case
- [ ] Error/invalid input
- [ ] Ambiguous request
- [ ] Missing info

---

Ready to use!

Quality Metrics

Additional Resources

For detailed examples and deep-dive topics:

• See references/ directory for complete examples
• Claude 4.x documentation
• MCP specification
• Anthropic prompt engineering guide

Version: 1.0.0 | Optimized for Claude 4.x