# Prompt Engineering Patterns

> This skill should be used when the user asks to "optimize a prompt", "improve prompt performance", "design a prompt template", "write better prompts", "debug prompt issues", "use chain-of-thought", "structured prompting", "few-shot prompting", or wants to apply advanced prompt engineering patterns for production LLM applications.

Source: https://skillsagentes.com/skills/wshobson/agents/prompt-engineering-patterns
Repository: https://github.com/wshobson/agents
Author: wshobson
License: MIT
Updated: el mes pasado
Context cost: 83 tok installed, 1.3k tok once triggered, 20.3k tok with every bundled file
Bundle: 10 files, 79 KB
Permissions requested: none declared

## Install

```bash
npx -y skills add wshobson/agents --skill prompt-engineering-patterns --agent claude-code
```

## What it does

- Aplica técnicas avanzadas de prompt engineering: few-shot learning, chain-of-thought, tree-of-thought y salidas estructuradas
- Diseña plantillas de prompts reutilizables con interpolación de variables y secciones condicionales
- Crea system prompts para asistentes especializados, definiendo rol, restricciones y formato de salida
- Enforza esquemas con Pydantic y modo JSON para parseo confiable de respuestas del LLM
- Guía la optimización iterativa y A/B testing de prompts midiendo precisión, consistencia y latencia

## Use it when

- Diseñar prompts complejos para aplicaciones LLM en producción
- Optimizar el rendimiento y la consistencia de un prompt
- Implementar razonamiento estructurado como chain-of-thought o tree-of-thought
- Depurar y refinar prompts que producen salidas inconsistentes

## What triggers it

- "Optimiza este prompt para que sea más consistente"
- "Ayúdame a diseñar una plantilla de prompt con variables"
- "Quiero usar chain-of-thought en este prompt de razonamiento"
- "Este prompt produce salidas inconsistentes, ayúdame a depurarlo"

## Files

- SKILL.md — 5 KB
- assets/few-shot-examples.json — 4 KB
- assets/prompt-template-library.md — 3 KB
- references/chain-of-thought.md — 9 KB
- references/details.md — 9 KB
- references/few-shot-learning.md — 11 KB
- references/prompt-optimization.md — 12 KB
- references/prompt-templates.md — 11 KB
- references/system-prompts.md — 5 KB
- scripts/optimize-prompt.py — 9 KB

## SKILL.md

Reproduced verbatim from wshobson/agents under MIT. This section is the upstream document and is in English.

# Prompt Engineering Patterns

Master advanced prompt engineering techniques to maximize LLM performance, reliability, and controllability.

## When to Use This Skill

- Designing complex prompts for production LLM applications
- Optimizing prompt performance and consistency
- Implementing structured reasoning patterns (chain-of-thought, tree-of-thought)
- Building few-shot learning systems with dynamic example selection
- Creating reusable prompt templates with variable interpolation
- Debugging and refining prompts that produce inconsistent outputs
- Implementing system prompts for specialized AI assistants
- Using structured outputs (JSON mode) for reliable parsing

## Core Capabilities

### 1. Few-Shot Learning

- Example selection strategies (semantic similarity, diversity sampling)
- Balancing example count with context window constraints
- Constructing effective demonstrations with input-output pairs
- Dynamic example retrieval from knowledge bases
- Handling edge cases through strategic example selection

### 2. Chain-of-Thought Prompting

- Step-by-step reasoning elicitation
- Zero-shot CoT with "Let's think step by step"
- Few-shot CoT with reasoning traces
- Self-consistency techniques (sampling multiple reasoning paths)
- Verification and validation steps

### 3. Structured Outputs

- JSON mode for reliable parsing
- Pydantic schema enforcement
- Type-safe response handling
- Error handling for malformed outputs

### 4. Prompt Optimization

- Iterative refinement workflows
- A/B testing prompt variations
- Measuring prompt performance metrics (accuracy, consistency, latency)
- Reducing token usage while maintaining quality
- Handling edge cases and failure modes

### 5. Template Systems

- Variable interpolation and formatting
- Conditional prompt sections
- Multi-turn conversation templates
- Role-based prompt composition
- Modular prompt components

### 6. System Prompt Design

- Setting model behavior and constraints
- Defining output formats and structure
- Establishing role and expertise
- Safety guidelines and content policies
- Context setting and background information

## Quick Start

```python
from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
from pydantic import BaseModel, Field

# Define structured output schema
class SQLQuery(BaseModel):
    query: str = Field(description="The SQL query")
    explanation: str = Field(description="Brief explanation of what the query does")
    tables_used: list[str] = Field(description="List of tables referenced")

# Initialize model with structured output
llm = ChatAnthropic(model="claude-sonnet-5")
structured_llm = llm.with_structured_output(SQLQuery)

# Create prompt template
prompt = ChatPromptTemplate.from_messages([
    ("system", """You are an expert SQL developer. Generate efficient, secure SQL queries.
    Always use parameterized queries to prevent SQL injection.
    Explain your reasoning briefly."""),
    ("user", "Convert this to SQL: {query}")
])

# Create chain
chain = prompt | structured_llm

# Use
result = await chain.ainvoke({
    "query": "Find all users who registered in the last 30 days"
})
print(result.query)
print(result.explanation)
```

## Detailed patterns and worked examples

Detailed pattern documentation lives in `references/details.md`. Read that file when the navigation tier above is insufficient.

## Best Practices

1. **Be Specific**: Vague prompts produce inconsistent results
2. **Show, Don't Tell**: Examples are more effective than descriptions
3. **Use Structured Outputs**: Enforce schemas with Pydantic for reliability
4. **Test Extensively**: Evaluate on diverse, representative inputs
5. **Iterate Rapidly**: Small changes can have large impacts
6. **Monitor Performance**: Track metrics in production
7. **Version Control**: Treat prompts as code with proper versioning
8. **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
- **No error handling**: Assuming outputs will always be well-formed
- **Hardcoded values**: Not parameterizing prompts for reuse

## Success Metrics

Track these KPIs for your prompts:

- **Accuracy**: Correctness of outputs
- **Consistency**: Reproducibility across similar inputs
- **Latency**: Response time (P50, P95, P99)
- **Token Usage**: Average tokens per request
- **Success Rate**: Percentage of valid, parseable outputs
- **User Satisfaction**: Ratings and feedback

---

Skills Agentes — https://skillsagentes.com/skills/wshobson/agents/prompt-engineering-patterns