PluginBench
Skill
Review
Audit score 70

prompt-engineer

jeffallan/claude-skills

Design, optimize, and evaluate LLM prompts with structured patterns, test suites, and performance metrics.

What is prompt-engineer?

Expert prompt engineering skill for writing and refactoring prompts that maximize LLM accuracy and efficiency. Use when designing new prompts, optimizing existing ones, implementing chain-of-thought or few-shot learning, creating system prompts with guardrails, building structured output schemas, or developing evaluation frameworks to measure model performance.

  • Generate optimized prompt templates using zero-shot, few-shot, and chain-of-thought patterns
  • Design and validate structured output schemas for JSON mode and function calling
  • Create system prompts with personas, guardrails, and injection defenses
  • Build evaluation frameworks with test cases and quantitative performance metrics
  • Refactor prompts for token efficiency, consistency, and accuracy
  • Debug poor LLM outputs by identifying instruction gaps and edge case failures

How to install prompt-engineer

npx skills add https://github.com/jeffallan/claude-skills --skill prompt-engineer
Claude Code
Cursor
Windsurf
Cline

How to use prompt-engineer

  1. 1.Define task requirements, success criteria, constraints, and edge cases
  2. 2.Choose a prompt pattern (zero-shot, few-shot, chain-of-thought) based on complexity
  3. 3.Write initial prompt with clear instructions, examples, and output format
  4. 4.Test with diverse inputs including edge cases and measure accuracy against baseline
  5. 5.Iterate one change at a time based on failure patterns; refactor for token efficiency
  6. 6.Document final prompt with usage instructions, metrics, limitations, and model version

Use cases

Good for
  • Designing prompts for new LLM applications with clear success criteria
  • Optimizing existing prompts that produce inconsistent or low-accuracy outputs
  • Implementing few-shot learning with examples matched to target distribution
  • Creating system prompts with specific personas and safety constraints
  • Building JSON schemas and function-calling interfaces for structured outputs
Who it's for
  • LLM application developers
  • Prompt engineers and AI practitioners
  • Teams building production LLM systems
  • Anyone refactoring or migrating prompts between models

prompt-engineer FAQ

When should I use few-shot vs. zero-shot prompts?

Use zero-shot for simple tasks with clear instructions. Use few-shot when you need higher accuracy, consistent formatting, or the task requires demonstrating patterns. Few-shot examples should match your target distribution.

How do I know if my prompt is working well?

Test with at least 20-30 diverse examples including edge cases. Measure quantitative metrics like accuracy, consistency, and token usage. If accuracy is below 80%, identify failure patterns (ambiguous instructions, missing examples, edge case gaps) before iterating.

Can I use the same prompt across different LLM models?

Prompts often need adjustment when switching models. Test across model versions before production deployment, as different models have different capabilities and may interpret instructions differently.

How do I optimize prompts for token efficiency?

Remove redundant instructions, use concise examples, specify exact output format to avoid verbose responses, and test token counts. Make one change at a time and measure impact on both accuracy and token usage.

What should I include in my final prompt documentation?

Include the final prompt with clear sections (role, task, constraints, format), test cases with results, usage instructions (temperature, max tokens, model version), performance metrics compared to baselines, and known limitations.

Full instructions (SKILL.md)

Source of truth, from jeffallan/claude-skills.


name: prompt-engineer description: Writes, refactors, and evaluates prompts for LLMs — generating optimized prompt templates, structured output schemas, evaluation rubrics, and test suites. Use when designing prompts for new LLM applications, refactoring existing prompts for better accuracy or token efficiency, implementing chain-of-thought or few-shot learning, creating system prompts with personas and guardrails, building JSON/function-calling schemas, or developing prompt evaluation frameworks to measure and improve model performance. license: MIT metadata: author: https://github.com/Jeffallan version: "1.2.0" domain: data-ml triggers: prompt engineering, prompt optimization, chain-of-thought, few-shot learning, prompt testing, LLM prompts, prompt evaluation, system prompts, structured outputs, prompt design, context management, lost-in-the-middle, context degradation, token optimization, attention budget role: expert scope: design output-format: document related-skills: test-master, rag-architect, debugging-wizard

Prompt Engineer

Expert prompt engineer specializing in designing, optimizing, and evaluating prompts that maximize LLM performance across diverse use cases.

When to Use This Skill

  • Designing prompts for new LLM applications
  • Optimizing existing prompts for better accuracy or efficiency
  • Implementing chain-of-thought or few-shot learning
  • Creating system prompts with personas and guardrails
  • Building structured output schemas (JSON mode, function calling)
  • Developing prompt evaluation and testing frameworks
  • Debugging inconsistent or poor-quality LLM outputs
  • Migrating prompts between different models or providers

Core Workflow

  1. Understand requirements — Define task, success criteria, constraints, and edge cases
  2. Design initial prompt — Choose pattern (zero-shot, few-shot, CoT), write clear instructions
  3. Test and evaluate — Run diverse test cases, measure quality metrics
    • Validation checkpoint: If accuracy < 80% on the test set, identify failure patterns before iterating (e.g., ambiguous instructions, missing examples, edge case gaps)
  4. Iterate and optimize — Make one change at a time; refine based on failures, reduce tokens, improve reliability
  5. Document and deploy — Version prompts, document behavior, monitor production

Reference Guide

Load detailed guidance based on context:

TopicReferenceLoad When
Prompt Patternsreferences/prompt-patterns.mdZero-shot, few-shot, chain-of-thought, ReAct
Optimizationreferences/prompt-optimization.mdIterative refinement, A/B testing, token reduction
Evaluationreferences/evaluation-frameworks.mdMetrics, test suites, automated evaluation
Structured Outputsreferences/structured-outputs.mdJSON mode, function calling, schema design
System Promptsreferences/system-prompts.mdPersona design, guardrails, injection defense
Context Managementreferences/context-management.mdAttention budget, degradation patterns, context optimization

Prompt Examples

Zero-shot vs. Few-shot

Zero-shot (baseline):

Classify the sentiment of the following review as Positive, Negative, or Neutral.

Review: {{review}}
Sentiment:

Few-shot (improved reliability):

Classify the sentiment of the following review as Positive, Negative, or Neutral.

Review: "The battery life is incredible, lasts all day."
Sentiment: Positive

Review: "Stopped working after two weeks. Very disappointed."
Sentiment: Negative

Review: "It arrived on time and matches the description."
Sentiment: Neutral

Review: {{review}}
Sentiment:

Before/After Optimization

Before (vague, inconsistent outputs):

Summarize this document.

{{document}}

After (structured, token-efficient):

Summarize the document below in exactly 3 bullet points. Each bullet must be one sentence and start with an action verb. Do not include opinions or information not present in the document.

Document:
{{document}}

Summary:

Constraints

MUST DO

  • Test prompts with diverse, realistic inputs including edge cases
  • Measure performance with quantitative metrics (accuracy, consistency)
  • Version prompts and track changes systematically
  • Document expected behavior and known limitations
  • Use few-shot examples that match target distribution
  • Validate structured outputs against schemas
  • Consider token costs and latency in design
  • Test across model versions before production deployment

MUST NOT DO

  • Deploy prompts without systematic evaluation on test cases
  • Use few-shot examples that contradict instructions
  • Ignore model-specific capabilities and limitations
  • Skip edge case testing (empty inputs, unusual formats)
  • Make multiple changes simultaneously when debugging
  • Hardcode sensitive data in prompts or examples
  • Assume prompts transfer perfectly between models
  • Neglect monitoring for prompt degradation in production

Output Templates

When delivering prompt work, provide:

  1. Final prompt with clear sections (role, task, constraints, format)
  2. Test cases and evaluation results
  3. Usage instructions (temperature, max tokens, model version)
  4. Performance metrics and comparison with baselines
  5. Known limitations and edge cases

Coverage Note

Reference files cover major prompting techniques (zero-shot, few-shot, CoT, ReAct, tree-of-thoughts), structured output patterns (JSON mode, function calling), context management (attention budgets, degradation mitigation, optimization), and model-specific guidance for GPT-4, Claude, and Gemini families. Consult the relevant reference before designing for a specific model or pattern.

Documentation