openai-prompt-engineer

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

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

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

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

Specific action to take

```

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

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:

What's wrong

File and line number

How to fix it

Improvement suggestion

```

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"

```

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:

```

Review this pull request for security issues

[Code to review]

• SQL injection vulnerabilities
• XSS attack vectors
• Authentication bypasses
• Data exposure risks

For each issue found, provide:

1. Severity (Critical/High/Medium/Low)
2. Location
3. Explanation
4. Fix recommendation

```

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"

```

Use this checklist to improve any prompt:

• [ ] Clear role defined - Is the AI's expertise specified?
• [ ] Specific task - Is it unambiguous what to do?
• [ ] Constraints listed - Are limitations clear?
• [ ] Format specified - Is output structure defined?
• [ ] Examples provided - Do you show what you want (if needed)?
• [ ] Reasoning enabled - Do you ask for step-by-step thinking (if complex)?
• [ ] Context included - Does the AI have necessary background?
• [ ] Edge cases covered - Are exceptions handled?
• [ ] Length specified - Is output length clear?
• [ ] Tone/style defined - Is the desired voice specified?

Problem: Vague Instructions

Before:

```

"Write some code for user authentication"

```

After:

```

"Write a TypeScript class called AuthService that:

• Accepts email/password credentials
• Validates against a User repository
• Returns a JWT token on success
• Throws AuthenticationError on failure
• Includes comprehensive JSDoc comments
• Follows dependency injection pattern"

```

Problem: No Examples (When Needed)

Before:

```

"Convert these variable names to camelCase"

```

After:

```

"Convert these variable names to camelCase:

user_name → userName

total_count → totalCount

is_active → isActive

Now convert:

order_status →

created_at →

max_retry_count →"

```

Problem: Missing Output Format

Before:

```

"Analyze this code for problems"

```

After:

```

"Analyze this code and output in this format:

• [Issue]: [Description] (Line X)

• [Issue]: [Description] (Line X)

• [Issue]: [Description] (Line X)

1. [Priority 1 fix]
2. [Priority 2 fix]"

```

Problem: Too Complex (Single Shot)

Before:

```

"Build a complete e-commerce backend with authentication,

payments, inventory, and shipping"

```

After (Progressive):

```

"Let's build this in stages:

Stage 1: Design the authentication system architecture

[Get response, review]

Stage 2: Implement the auth service

[Get response, review]

Stage 3: Add payment processing

[Continue...]"

```

Generate a New Prompt

Ask:

```

"Using the prompt-engineer skill, create a prompt for:

[Describe your task and requirements]"

```

You'll get:

• Structured prompt template
• Recommended techniques
• Example few-shots if applicable
• Model-specific optimizations

Improve an Existing Prompt

Ask:

```

"Using the prompt-engineer skill, improve this prompt:

[Your current prompt]

Goal: [What you want to achieve]

Model: [GPT-5 / Claude / Other]"

```

You'll get:

• Analysis of current issues
• Improved version
• Explanation of changes
• Expected improvement in results

Analyze Prompt Quality

Ask:

```

"Using the prompt-engineer skill, analyze this prompt:

[Your prompt]"

```

You'll get:

• Quality score
• Identified weaknesses
• Specific improvement suggestions
• Best practices violations

Example 1: Code Review Prompt

Task: Get thorough, consistent code reviews

Optimized Prompt:

```

ROLE: Senior Software Engineer conducting PR review

REVIEW THIS CODE:

[code block]

REVIEW CRITERIA:

1. Security vulnerabilities (OWASP Top 10)
2. Performance issues
3. Code quality and readability
4. Best practices compliance
5. Test coverage gaps

OUTPUT FORMAT:

For each issue found:

• Severity: [Critical/High/Medium/Low]
• Category: [Security/Performance/Quality/Testing]
• Location: [File:Line]
• Issue: [Clear description]
• Impact: [Why this matters]
• Fix: [Specific code recommendation]

At the end, provide:

• Overall assessment (Approve/Request Changes/Comment)
• Summary of critical items that must be fixed

```

Example 2: Technical Documentation

Task: Generate clear API documentation

Optimized Prompt:

```

ROLE: Technical writer with API documentation expertise

TASK: Generate API documentation for this endpoint

ENDPOINT DETAILS:

[code/specs]

DOCUMENTATION REQUIREMENTS:

• Target audience: Junior to mid-level developers
• Include curl and JavaScript examples
• Explain all parameters clearly
• Show example responses with descriptions
• Include common error cases
• Add troubleshooting section

FORMAT:

# [Endpoint Name]

[One paragraph description]

[HTTP METHOD] /path

| Name | Type | Required | Description |

|------|------|----------|-------------|

```bash

[curl example]

```

Success (200)

```json

[example with inline comments]

```

Errors

• 400: [Description and fix]
• 401: [Description and fix]

[Troubleshooting guide]

```

Example 3: Data Analysis

Task: Analyze data and provide insights

Optimized Prompt:

```

ROLE: Data analyst with expertise in business metrics

DATA:

[dataset]

ANALYSIS REQUEST:

Analyze this data step-by-step:

1. FIRST: Identify key metrics and trends
2. THEN: Calculate:

- Growth rate (month-over-month)

- Average values

- Anomalies or outliers

1. NEXT: Draw business insights
2. FINALLY: Provide actionable recommendations

OUTPUT FORMAT:

[2-3 sentences]

| Metric | Value | Change | Trend |

1. [Insight with supporting data]
2. [Insight with supporting data]

1. [Action]: [Expected impact]
2. [Action]: [Expected impact]

[Brief explanation of analysis approach]

```

DO ✅

• Be specific - Exact requirements, not vague requests
• Use structure - Organize with clear sections
• Provide examples - Show what you want (few-shot)
• Request reasoning - "Think step-by-step" for complex tasks
• Define format - Specify exact output structure
• Test iteratively - Refine based on results
• Match to model - Use model-specific techniques
• Include context - Give necessary background
• Handle edge cases - Specify exception handling
• Set constraints - Define limitations clearly

DON'T ❌

• Be vague - "Write something about X"
• Skip examples - When patterns need to be matched
• Assume format - Model will choose unpredictably
• Overload single prompt - Break complex tasks into stages
• Ignore model differences - GPT-5 and Claude need different approaches
• Give up too soon - Iterate on prompts
• Mix instructions - Keep separate concerns separate
• Forget constraints - Specify ALL requirements
• Use ambiguous terms - "Good", "professional", "better" without definition
• Skip testing - Always validate outputs

Prompt Template (Universal)

```

[ROLE]

You are [specific expertise]

[CONTEXT]

[Background information]

[TASK]

[Clear, specific task]

[CONSTRAINTS]

• [Limit 1]
• [Limit 2]

[FORMAT]

[Exact output structure]

[EXAMPLES - Optional]

[2-3 examples]

[REASONING - Optional]

Think through this step-by-step:

[Thinking guidance]

```

When to Use Each Technique

| Technique | Best For | Example Use Case |

|-----------|----------|------------------|

| Chain-of-Thought | Complex reasoning | Math, logic puzzles, multi-step analysis |

| Few-Shot | Pattern matching | Classification, style transfer, formatting |

| Zero-Shot | Simple, clear tasks | Direct questions, basic transformations |

| Structured (XML) | Parsed output | Data extraction, API responses |

| Progressive Disclosure | Large tasks | Full implementations, research |

| Role-Based | Expert knowledge | Code review, architecture decisions |

Model Selection Guide

Use GPT-5 when:

• Need strong reasoning
• Agentic behavior helpful
• Code generation focus
• Latest knowledge needed

Use Claude when:

• Very long context (100K+ tokens)
• Detailed instruction following
• Safety-critical applications
• Prefer XML structuring

All reference materials included:

• GPT-5 specific techniques and patterns
• Claude optimization strategies
• Advanced prompting patterns
• Optimization and improvement frameworks

Effective prompt engineering:

• Saves time - Get right results faster
• Reduces costs - Fewer API calls needed
• Improves quality - More accurate, consistent outputs
• Enables complexity - Tackle harder problems
• Scales knowledge - Capture best practices

Use this skill to create prompts that:

• Are clear and specific
• Use proven techniques
• Match your model
• Get consistent results
• Achieve your goals

---

Remember: A well-crafted prompt is worth 10 poorly-attempted ones. Invest time upfront for better results.