openai-reusable-prompts

Files (4)

• SKILL.md
• index.md · references/
• prompt-engineering.md · references/
• realtime-prompting.md · references/

SKILL.md (first lines)

# OpenAI Reusable Prompts

## Summary

This skill focuses only on writing high-quality prompts and formatting them for clarity, consistency, and better model steerability.

It helps define prompt structure, wording quality, examples, and formatting patterns for reliable outputs.

See [references](references/) for detailed OpenAI prompt engineering guides.

## When to use

- You want better-written prompts with clear instruction hierarchy.
- You need consistent prompt formatting across tasks or teams.
- You want reusable prompt templates with strong examples and constraints.
- You need to improve ambiguous prompts that produce inconsistent output.
- You are standardizing a stable, repeatable procedure that multiple agents or teams should share.
- You want reusable behavior that can be versioned and improved independently over time.

## When not to use

- You are asking for API integration code, deployment, or version rollout strategy.
- You need runtime implementation details instead of prompt writing guidance.
- The request is truly one-off and does not need reusable structure.
- The procedure changes daily and has not stabilized yet.
- The task primarily requires live external state or side effects; use tools or APIs for that.

## Required inputs

Provide or infer:

- Outcome: what the prompt must produce.
- Audience or task type: who uses the output and for what.
- Output contract: free text, markdown, JSON, or schema-constrained output.
- Constraints: style, tone, safety limits, and forbidden behavior.

If relevant, also capture example inputs and expected outputs.

If details are missing, ask only the minimum needed to author a usable v1 template.

## Routing guidance and edge cases

- Prefer triggering this skill for reusable procedures, stable writing standards, or organization-wide prompt conventions.
- Avoid triggering this skill when the user asks for ad hoc brainstorming that does not require strict structure.
- Include both positive and negative examples in your authored prompt package to improve routing accuracy.
- If routing is inconsistent, iterate on frontmatter `name`, `description`, and examples before changing scripts or runtime code.

## Procedure

1. **Define the target behavior**
   - Write a one-sentence objective for the prompt.
   - Define success as observable output criteria.

2. **Set instruction hierarchy**
   - Put high-priority behavior first.
   - Separate required rules from preferences.
   - State what the model must do and must not do.
   - Put reusable application rules in the Responses API `instructions` parameter or a `developer` message; they take priority over `user` input.
   - Do not rely on `instructions` from a prior turn when using `previous_response_id`; send them again.

3. **Draft the prompt with consistent formatting**
   - Use clear section headers in this order when useful: `Identity`, `Instructions`, `Examples`, `Context`.
   - Keep instructions explicit and testable.
   - Use placeholders for dynamic values, for example `{{customer_name}}`.
   - Keep stable, repeated content near the beginning to improve prompt-cache savings.

4. **Strengthen formatting discipline**
   - Use bullet lists for constraints and output rules.
   - Use XML-style delimiters for example I/O blocks when helpful.
   - Avoid long paragraphs that hide requirements.

5. **Add examples that teach behavior**
   - Use a diverse handful of examples when they materially improve reliability, especially for strict formats.
   - Cover common and edge inputs.
   - Keep examples consistent with stated rules.

6. **Add output contract checks**
   - Specify exact format expectations (fields, ordering, allowed labels).
   - Add explicit negative constraints to reduce drift.

7. **Revise for clarity and brevity**
   - Remove redundant instructions.
   - Replace vague wording with measurable requirements.
   - Keep only context that changes model decisions.
   - For GPT models, use precise instructions. For reasoning models, begin with higher-level goals and add detail only when evaluation results require it.

8. **Add operational readiness notes when the prompt will be used as a skill artifact**
   - Include when to use, how to run, expected outputs, and gotchas.
   - Add explicit verification steps and output checks for brittle multi-step workflows.

## Branching logic

- If output must follow strict schema:
  Use explicit field-level formatting rules and schema-like examples.

- If behavior differs by customer or locale:
  Keep global rules stable and isolate locale-specific rules in dedicated context blocks.

- If the prompt is long and complex:
  Split sections clearly and remove non-essential context.

- If task is reasoning-heavy and under-specified:
  Start with goal + constraints, then tighten with examples after observing failures.

- If task is deterministic and format-sensitive:
  Use strict format instructions and highly specific examples.

## Quality criteria

A skill run is complete when all are true:

- Prompt objective and output contract are explicit.
- Instruction hierarchy is clear (must vs should).
- Formatting is consistent across sections.
- Examples reinforce the required behavior and format.
- Ambiguous wording has been removed.
- Negative trigger examples are present for routing precision.
- Verification steps and output checks are defined when workflow execution is multi-step.
- Representative fixtures, tests, and evaluation checks cover production prompt changes.

From nathanfaucett/agents, MIT.

More from nathanfaucett/agents