Generated banner for Prompt Optimizer
Generated logo for Prompt Optimizer

Prompt Optimizer

SentryOfficialPublished by Sentry

  • Skill
  • Workflow
  • Agent tooling
  • Apache-2.0
  • No issues found

From the author

Creates, optimizes, and iteratively refines agent prompts, system prompts, developer prompts, and reusable prompt templates. Use when asked to improve a prompt, optimize a system prompt, rewrite an agent prompt, tune prompt wording, make a prompt more reliable, port prompts between OpenAI, Claude, or Gemini, or build prompt evals.
— the description by Sentry

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The Prompt Optimizer provides a rigorous, systematic approach to prompt engineering. Rather than relying on intuition, it mandates the creation of evaluation sets (evals) to measure performance, identify failure modes, and validate improvements. The workflow guides users through capturing contract requirements, inventorying external context, choosing model-specific strategies, and executing a disciplined optimization loop. It emphasizes separating stable policy from task-local context and provides a structured method for comparing candidate prompts to ensure changes are causal and effective.

What it does

  • Defines a structured contract for prompt requirements, success criteria, and constraints.
  • Establishes a repeatable optimization loop using evaluation sets to cluster and address failure modes.
  • Provides patterns for layering prompts to separate stable policy from dynamic user input.
  • Offers strategies for porting prompts across different model families like OpenAI, Claude, and Gemini.
  • Maintains an optimization log to track hypotheses, edits, and results to prevent regression.
  • Validates prompt candidates against holdout cases to ensure robustness and prevent overfitting.

When to use it

  • When you need to improve the reliability or performance of an existing agent or system prompt.
  • When porting a prompt between different LLM providers or model versions.
  • When a prompt is failing consistently on specific edge cases or ambiguous inputs.
  • When you need to build a reusable prompt template that maintains consistent behavior across tasks.
  • When you want to move from ad-hoc prompt editing to a data-driven, evidence-based development process.

Advantages

  • Reduces guesswork by grounding all edits in concrete evaluation results.
  • Prevents prompt bloat by enforcing clear separation between policy, examples, and context.
  • Ensures behavioral consistency by using holdout validation to check for regressions.
  • Provides a clear, repeatable framework for team-based prompt development.
  • Helps identify when failures are due to model limitations rather than prompt wording.

Usage examples

“Optimize my customer support agent prompt to reduce hallucinations regarding refund policies.”
The agent will guide you to define success criteria, create a small eval set of refund queries, cluster current failure modes, and iteratively refine the prompt's policy section until performance stabilizes.
“Port this system prompt from GPT-4 to Claude 3.5 Sonnet.”
The agent will analyze the original prompt, identify model-specific dependencies, create a portable base, and generate adapter notes to ensure consistent behavior on the new model family.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/getsentry/prompt-optimizer/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip prompt-optimizer.zip -d .agents/skills

Documentation by Sentry

Prompt Optimizer

Optimize prompts with evals. Keep every instruction, example, and external context reference causal.

Load Only What You Need

NeedRead
New promptreferences/core-patterns.md, references/model-family-notes.md, references/transformed-examples.md
Existing promptreferences/meta-optimization-loop.md, references/core-patterns.md, references/model-family-notes.md
Model-family portreferences/model-family-notes.md, references/core-patterns.md
Repeated failuresreferences/meta-optimization-loop.md, references/core-patterns.md
Weak or ambiguous draftreferences/transformed-examples.md
ProvenanceSOURCES.md

Step 1: Capture Contract

Record before editing:

  • task type: new, refine, port, or debug

  • target model family and snapshot, if known

  • prompt surface: system, developer, user, tool descriptions, examples, schemas

  • layer owners: platform, deployer/persona, retrieved context, user payload

  • objective and non-goals

  • inputs, tools, and external files available

  • required output shape

  • success criteria and failure cases

  • hard constraints: latency, verbosity, safety, budget, tool use, style

If success criteria or examples are missing, create a small eval set first. If the bottleneck is model choice, retrieval, tool schema, or missing evals, say so before rewriting.

Step 2: Inventory External Context

For repo or agent prompts, list stable context by exact path:

Context typeExamples
Agent rulesAGENTS.md, CLAUDE.md
Specsspecs/*.md, docs/api.md
PoliciesSECURITY.md, docs/releasing.md
Examplesexamples/, tests/fixtures/

Rules:

  • Reference stable files by repo-relative path instead of copying them.

  • Paste only excerpts needed for the prompt or eval case.

  • Mark whether a file is loaded, referenced, or out of scope.

  • Avoid vague context pointers such as "read the docs".

Step 3: Choose Model Strategy

Read references/model-family-notes.md.

  • Known family: optimize for that family.

  • Unknown family: write a portable base plus short adapter notes.

  • Snapshot changes: rerun evals.

  • Cross-family divergence: specialize only the failing layer.

Step 4: Shape Prompt

Read references/core-patterns.md.

  • Put stable policy in system or developer.

  • Put task-local facts, retrieved context, and variables in user-facing sections.

  • Keep one owner per behavior rule.

  • Use headings or tags only to separate content types.

  • Put tool policy in prompt text; keep schemas in provider-native tools.

  • Keep persona light unless it changes behavior.

  • Use the shortest wording that preserves the constraint.

  • Cut filler, repeated reminders, dead examples, and rationale that does not affect evals.

Step 5: Optimize

Read references/meta-optimization-loop.md for refinements.

  1. Baseline the current prompt on the same eval slice.

  2. Cluster failures by root cause.

  3. Write concrete edit criticisms.

  4. Generate two to four candidates:

    • minimal-diff repair

    • structure-first rewrite

    • examples-first or tool-rule variant

    • provider adapter when needed

  5. Compare candidates on the same cases.

  6. Keep a short optimization log.

  7. Validate the winner on holdout cases.

  8. Stop on plateau, oscillation, overfit, excessive cost, or non-prompt bottleneck.

Step 6: Return Package

Return:

  1. Target

  2. Success Criteria

  3. External Context

  4. Optimized Prompt

  5. Adapter Notes

  6. Eval Set

  7. Optimization Log

  8. Residual Risks

For existing prompts, include a concise diff-style note of the main behavioral changes.

Failure Modes

  • editing before defining the eval target

  • mixing policy, examples, and raw context without boundaries

  • duplicating rules across layers

  • putting durable policy in user payloads

  • asking for chain-of-thought

  • keeping contradictory legacy instructions

  • overfitting to one or two examples

  • retaining examples that no longer improve evals

  • fixing tool-use failures only in prompt text when tool descriptions or schemas are weak

  • adding markup that does not reduce ambiguity

  • using persona as a substitute for behavior rules

Files

references/core-patterns.md

Core Patterns

When markers help

Use markers when the prompt mixes different content types:

  • instructions

  • retrieved context

  • tool rules

  • examples

  • input payloads

  • output schema

Good section names are concrete and stable:

  • <role>

  • <goal>

  • <context>

  • <tool_policy>

  • <workflow>

  • <constraints>

  • <output_format>

Do not add markup around every sentence. Markers are useful when they carve the prompt into distinct blocks, not when they add noise.

If the target stack or model family responds better to plain markdown, use headings and bullets instead of XML-style tags. The structure matters more than the syntax.

Where rules live
Block typeExamplesContent
descriptive<context>, <state>, <environment>facts, inputs, current state
rules<behavior>, <constraints>, <tool_policy>, <workflow>directives

Rules:

  • Keep descriptive markers descriptive.

  • Put directives in canonical rules sections.

  • For state-conditional rules, write the directive in a rules section and reference the state by name.

Layer the prompt correctly

Keep these layers separate:

  1. Stable behavior:

  • role

  • defaults

  • safety boundaries

  • tool-use policy

  • output contract

  1. Task-local context:

  • user request

  • retrieved documents

  • current state

  • dynamic variables

  1. Examples:

  • few-shot examples

  • failure replays

  • structured output demonstrations

If a rule should apply across tasks, keep it out of the user payload and put it in the stable layer. Keep one authoritative owner for each major behavior rule instead of repeating it across all layers.

Collapse common duplicates such as:

  • verbosity rules

  • "check before guessing"

  • ask-first versus act-now behavior

  • output format rules

  • refusal and escalation boundaries

When prompts are long, separate policy from evidence explicitly:

  • instructions in one block

  • retrieved documents in another

  • examples in another

  • tool policy (when/why/whether) in its own labeled section; tool schemas stay in the provider-native tools parameter

For long-context prompts, place long evidence before the final query and keep the actual ask in a terminal section. Do not cargo-cult this ordering into short prompts that do not need it.

Layered prompts with multiple owners

When a runtime concatenates prompt layers from different owners:

LayerOwnsMust not own
platformtool policy, output contract, safety, escalation, workflowvoice-only identity
deployer/personavoice, tone, domain framing, sparse identity filesload-bearing behavior
user payloadtask facts, variables, current requestdurable policy

Rules:

  • Platform behavior must work when AGENTS.md, CLAUDE.md, or persona files are empty or customized.

  • Do not delete platform rules because a deployer layer "probably covers it".

  • Put load-bearing rules in the highest stable owner.

External file inventories

Use path inventories when prompts depend on repo docs, specs, or policies.

<external_files>
- `AGENTS.md` - repo agent rules; loaded
- `docs/api.md` - API contract; reference before endpoint changes
- `SECURITY.md` - security policy; reference for disclosure or auth changes
</external_files>

Rules:

  • Enumerate exact repo-relative paths.

  • Mark each file as loaded, referenced, or out of scope.

  • Paste only excerpts needed for the prompt or eval case.

  • Prefer docs/api.md over "read the docs".

  • Keep stable docs outside the prompt when the runtime can retrieve files.

Tool policy placement

  • Tool schemas belong in provider-native tools.

  • Prompt text carries tool policy: when, why, whether, evidence, and stop conditions.

  • Naming a tool in policy is fine; re-enumerating schemas is not.

High-value prompt moves

  • Tell the agent what to do by default.

  • State when it should ask clarifying questions and when it should infer.

  • State when it should use tools and what evidence it should gather before acting.

  • State what counts as completion.

  • State what counts as refusal, escalation, or defer.

  • Enumerate external files by path when specs, docs, or policies matter.

  • Separate hard constraints from preferences.

  • Keep progress-update style explicit if the user should see it.

  • Use the shortest wording that preserves the intended behavioral constraint.

  • Remove persona, motivation, or reminder text that does not change measured behavior.

  • Place directives in canonical rules sections (<behavior>, <constraints>, <tool_policy>, <workflow>), not buried inside descriptive markers like <context>, <state>, or <turn-state>.

Symptom to fix mapping

SymptomLikely fix
Output format driftsAdd a stronger output contract or a format example
The agent guesses instead of checkingAdd tool-use criteria and "gather facts before acting" language
The agent stays too passiveAdd explicit default behavior and action bias
The agent is too aggressiveAdd ask-first and escalation boundaries
Responses are verboseTighten output sections and verbosity constraints
The prompt is long but still unstableRemove duplicate rules and choose one owner per behavior
Long context causes confusionSeparate context from instructions and move the query to a clear terminal section
The prompt works on one provider but not anotherSplit base prompt from provider-specific adapter notes

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by
Sentry
Publisher
Sentry (Official)
Source
getsentry/skills · skills/prompt-optimizer · commit e94f222
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Sentry.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download prompt-optimizer.zip