openai-prompt-engineer

What this skill does

# OpenAI Prompt Engineer

A comprehensive skill for crafting, analyzing, and improving prompts for OpenAI's GPT-5 and other modern Large Language Models (LLMs), with focus on GPT-5-specific optimizations and universal prompting techniques.

## What This Skill Does

Helps you create and optimize prompts using cutting-edge techniques:
- **Generate new prompts** - Build effective prompts from scratch
- **Improve existing prompts** - Enhance clarity, structure, and results
- **Apply best practices** - Use proven techniques for each model
- **Optimize for specific models** - GPT-5, Claude-specific strategies
- **Implement advanced patterns** - Chain-of-thought, few-shot, structured prompting
- **Analyze prompt quality** - Identify issues and suggest improvements

## Why Prompt Engineering Matters

**Without good prompts:**
- Inconsistent or incorrect outputs
- Poor instruction following
- Wasted tokens and API costs
- Multiple attempts needed
- Unpredictable behavior

**With optimized prompts:**
- Accurate, consistent results
- Better instruction adherence
- Lower costs and latency
- First-try success
- Predictable, reliable outputs

## Supported Models & Approaches

### GPT-5 (OpenAI)
- Structured prompting (role + task + constraints)
- Reasoning effort calibration
- Agentic behavior control
- Verbosity management
- Prompt optimizer integration

### Claude (Anthropic)
- XML tag structuring
- Step-by-step thinking
- Clear, specific instructions
- Example-driven prompting
- Progressive disclosure

### Universal Techniques
- Chain-of-thought prompting
- Few-shot learning
- Zero-shot prompting
- Self-consistency
- Role-based prompting

## Core Prompting Principles

### 1. Be Clear and Specific
**Bad:** "Write about AI"
**Good:** "Write a 500-word technical article explaining transformer architecture for software engineers with 2-3 years of experience. Include code examples in Python and focus on practical implementation."

### 2. Provide Structure
Use clear formatting to organize instructions:
```
Role: You are a senior Python developer
Task: Review this code for security vulnerabilities
Constraints:
- Focus on OWASP Top 10
- Provide specific line numbers
- Suggest fixes with code examples
Output format: Markdown with severity ratings
```

### 3. Use Examples (Few-Shot)
Show the model what you want:
```
Input: "User clicked login"
Output: "USER_LOGIN_CLICKED"

Input: "Payment processed successfully"
Output: "PAYMENT_PROCESSED_SUCCESS"

Input: "Email verification failed"
Output: [Your turn]
```

### 4. Enable Reasoning
Add phrases like:
- "Think step-by-step"
- "Let's break this down"
- "First, analyze... then..."
- "Show your reasoning"

### 5. Define Output Format
Specify exactly how you want the response:
```xml
<output_format>
  <summary>One sentence overview</summary>
  <details>
    <point>Key finding 1</point>
    <point>Key finding 2</point>
  </details>
  <recommendation>Specific action to take</recommendation>
</output_format>
```

## Prompt Engineering Workflow

### 1. Define Your Goal
- What task are you solving?
- What's the ideal output?
- Who's the audience?
- What model will you use?

### 2. Choose Your Technique
- **Simple task?** → Direct instruction
- **Complex reasoning?** → Chain-of-thought
- **Pattern matching?** → Few-shot examples
- **Need consistency?** → Structured format + examples

### 3. Build Your Prompt
Use this template:
```
[ROLE/CONTEXT]
You are [specific role with relevant expertise]

[TASK]
[Clear, specific task description]

[CONSTRAINTS]
- [Limitation 1]
- [Limitation 2]

[FORMAT]
Output should be [exact format specification]

[EXAMPLES - if using few-shot]
[Example 1]
[Example 2]

[THINK STEP-BY-STEP - if complex reasoning]
Before answering, [thinking instruction]
```

### 4. Test and Iterate
- Run the prompt
- Analyze output quality
- Identify issues
- Refine and retry
- Document what works

## Advanced Techniques

### Chain-of-Thought (CoT) Prompting

**When to use:** Complex reasoning, math, multi-step problems

**How it works:** Ask the model to show intermediate steps

**Example:**
```
Problem: A store has 15 apples. They sell 60% in the morning and
half of what's left in the afternoon. How many remain?

Please solve this step-by-step:
1. Calculate morning sales
2. Calculate remaining after morning
3. Calculate afternoon sales
4. Calculate final remaining
```

**Result:** More accurate answers through explicit reasoning

### Few-Shot Prompting

**When to use:** Pattern matching, classification, style transfer

**How it works:** Provide 2-5 examples, then the actual task

**Example:**
```
Convert casual text to professional business tone:

Input: "Hey! Thanks for reaching out. Let's chat soon!"
Output: "Thank you for your message. I look forward to our conversation."

Input: "That's a great idea! I'm totally on board with this."
Output: "I appreciate your suggestion and fully support this initiative."

Input: "Sounds good, catch you later!"
Output: [Model completes]
```

### Zero-Shot Chain-of-Thought

**When to use:** Complex problems without examples

**How it works:** Simply add "Let's think step by step"

**Example:**
```
Question: What are the security implications of storing JWTs
in localStorage?

Let's think step by step:
```

**Magic phrase:** "Let's think step by step" → dramatically improves reasoning

### Structured Output with XML

**When to use:** Working with Claude or need parsed output

**Example:**
```
Analyze this code for issues. Structure your response as:

<analysis>
  <security_issues>
    <issue severity="high|medium|low">
      <description>What's wrong</description>
      <location>File and line number</location>
      <fix>How to fix it</fix>
    </issue>
  </security_issues>
  <performance_issues>
    <!-- Same structure -->
  </performance_issues>
  <best_practices>
    <suggestion>Improvement suggestion</suggestion>
  </best_practices>
</analysis>
```

### Progressive Disclosure

**When to use:** Large context, multi-step workflows

**How it works:** Break tasks into stages, only request what's needed now

**Example:**
```
Stage 1: "Analyze this codebase structure and list the main components"
[Get response]

Stage 2: "Now, for the authentication component you identified,
show me the security review"
[Get response]

Stage 3: "Based on that review, generate fixes for the high-severity issues"
```

## Model-Specific Best Practices

### GPT-5 Optimization

**Structured Prompting:**
```
ROLE: Senior TypeScript Developer
TASK: Implement user authentication service
CONSTRAINTS:
- Use JWT with refresh tokens
- TypeScript with strict mode
- Include comprehensive error handling
- Follow SOLID principles
OUTPUT: Complete TypeScript class with JSDoc comments
REASONING_EFFORT: high (for complex business logic)
```

**Control Agentic Behavior:**
```
"Implement this feature step-by-step, asking for confirmation
before each major decision"

OR

"Complete this task end-to-end without asking for guidance.
Persist until fully handled."
```

**Manage Verbosity:**
```
"Provide a concise implementation (under 100 lines) focusing
only on core functionality"
```

### Claude Optimization

**Use XML Tags:**
```
<instruction>
Review this pull request for security issues
</instruction>

<code>
[Code to review]
</code>

<focus_areas>
- SQL injection vulnerabilities
- XSS attack vectors
- Authentication bypasses
- Data exposure risks
</focus_areas>

<output_format>
For each issue found, provide:
1. Severity (Critical/High/Medium/Low)
2. Location
3. Explanation
4. Fix recommendation
</output_format>
```

**Step-by-Step Thinking:**
```
Think through this architecture decision step by step:
1. First, identify the requirements
2. Then, list possible approaches
3. Evaluate trade-offs for each
4. Make a recommendation with reasoning
```

**Clear Specificity:**
```
BAD: "Make the response professional"
GOOD: "Use formal business language, avoid contractions,
address the user as 'you', keep sentences under 20 words"
```