Initial commit

skills/openai-prompt-engineer/references/prompt_patterns.md

@@ -0,0 +1,919 @@
+# Prompt Patterns & Templates
+
+## Overview
+
+This guide provides reusable prompt patterns and templates for common tasks. Each pattern includes the template, usage guidelines, and examples.
+
+## Pattern Categories
+
+1. **Code Generation** - Creating code from specifications
+2. **Analysis & Review** - Evaluating code, documents, data
+3. **Content Creation** - Writing documentation, articles, etc.
+4. **Data Processing** - Transforming, extracting, analyzing data
+5. **Decision Support** - Helping make informed choices
+6. **Learning & Teaching** - Explaining concepts, tutoring
+7. **Debugging & Troubleshooting** - Finding and fixing problems
+
+---
+
+## Code Generation Patterns
+
+### Pattern: Feature Implementation
+
+**Use when:** Building a new feature or component
+
+**Template:**
+```
+ROLE: Expert [language] developer following [style guide/framework]
+
+FEATURE REQUEST:
+[Description of feature to implement]
+
+TECHNICAL REQUIREMENTS:
+- Language/Framework: [specific versions]
+- Architecture: [pattern to follow]
+- Dependencies: [what you can use]
+- Constraints: [limitations]
+
+CODE STANDARDS:
+- [Naming conventions]
+- [Documentation requirements]
+- [Error handling approach]
+- [Testing requirements]
+
+DELIVERABLES:
+1. Main implementation
+2. Unit tests
+3. Integration tests (if applicable)
+4. Usage example
+5. Brief documentation
+
+OUTPUT STRUCTURE:
+[Specify files, organization]
+```
+
+**Example:**
+```
+ROLE: Expert TypeScript developer following Airbnb style guide
+
+FEATURE REQUEST:
+Implement a caching service with TTL support and LRU eviction
+
+TECHNICAL REQUIREMENTS:
+- Language/Framework: TypeScript 5.0+, Node.js
+- Architecture: Service class with dependency injection
+- Dependencies: Only Node.js built-ins
+- Constraints: Must be memory-efficient, thread-safe
+
+CODE STANDARDS:
+- Use strict TypeScript types
+- JSDoc comments for public methods
+- Explicit error handling with custom exceptions
+- 80%+ code coverage
+
+DELIVERABLES:
+1. CacheService class implementation
+2. Comprehensive unit tests
+3. Usage examples
+4. Performance considerations doc
+
+OUTPUT STRUCTURE:
+- src/services/CacheService.ts
+- src/services/__tests__/CacheService.test.ts
+- examples/cache-usage.ts
+```
+
+### Pattern: Code Refactoring
+
+**Use when:** Improving existing code
+
+**Template:**
+```
+ROLE: Senior developer performing code refactoring
+
+CURRENT CODE:
+[Code to refactor]
+
+REFACTORING GOALS:
+1. [Goal 1 - e.g., reduce complexity]
+2. [Goal 2 - e.g., improve testability]
+3. [Goal 3 - e.g., enhance performance]
+
+CONSTRAINTS:
+- Maintain backward compatibility: [yes/no]
+- Keep same API surface: [yes/no]
+- Preserve functionality exactly: [yes/no]
+
+EVALUATION CRITERIA:
+- Cyclomatic complexity < [number]
+- No functions > [number] lines
+- [Other measurable improvements]
+
+OUTPUT:
+1. Refactored code
+2. Explanation of changes
+3. Before/after comparison
+4. Test plan for validation
+```
+
+### Pattern: Bug Fix
+
+**Use when:** Diagnosing and fixing bugs
+
+**Template:**
+```
+ROLE: Senior debugger and problem solver
+
+BUG REPORT:
+Symptoms: [What's happening]
+Expected: [What should happen]
+Steps to reproduce: [How to trigger]
+
+CODE:
+[Relevant code sections]
+
+CONTEXT:
+- Environment: [runtime, versions]
+- Recent changes: [what changed recently]
+- Error messages: [any errors]
+
+DEBUGGING APPROACH:
+1. Analyze code for potential issues
+2. Identify root cause
+3. Propose fix
+4. Suggest tests to prevent regression
+
+OUTPUT:
+## Root Cause
+[Explanation]
+
+## Proposed Fix
+[Code changes]
+
+## Testing
+[How to verify fix]
+
+## Prevention
+[How to avoid similar bugs]
+```
+
+---
+
+## Analysis & Review Patterns
+
+### Pattern: Code Review
+
+**Use when:** Reviewing pull requests or code changes
+
+**Template:**
+```
+ROLE: Senior engineer conducting code review
+
+CODE TO REVIEW:
+[Code or diff]
+
+REVIEW FOCUS:
+1. Security vulnerabilities
+2. Performance issues
+3. Code quality and maintainability
+4. Best practices adherence
+5. Test coverage
+6. Documentation
+
+SEVERITY LEVELS:
+- Critical: Must fix before merge
+- High: Should fix before merge
+- Medium: Should fix soon
+- Low: Nice to have
+
+OUTPUT FORMAT:
+For each issue:
+### [Issue Title]
+- **Severity**: [Level]
+- **Category**: [Security/Performance/Quality/Tests/Docs]
+- **Location**: `[file]:[line]`
+- **Issue**: [What's wrong]
+- **Why**: [Why it matters]
+- **Fix**: [How to fix it]
+
+SUMMARY:
+- Overall assessment: Approve / Request Changes / Comment
+- Critical/High issues: [count]
+- Recommendation: [merge or not]
+```
+
+### Pattern: Architecture Review
+
+**Use when:** Evaluating system design decisions
+
+**Template:**
+```
+ROLE: Solutions architect reviewing system design
+
+PROPOSED ARCHITECTURE:
+[Architecture description, diagrams, specs]
+
+EVALUATION FRAMEWORK:
+1. **Scalability**: Can it handle growth?
+2. **Reliability**: Single points of failure?
+3. **Performance**: Will it meet SLAs?
+4. **Security**: Threat model coverage?
+5. **Maintainability**: Easy to change/debug?
+6. **Cost**: Resource efficiency?
+
+CONTEXT:
+- Expected scale: [users, requests, data]
+- Team size: [developers]
+- Timeline: [when needed]
+- Constraints: [technical, business]
+
+OUTPUT:
+For each dimension:
+## [Dimension]
+- Assessment: [Good/Concerns/Critical Issues]
+- Analysis: [Detailed evaluation]
+- Risks: [What could go wrong]
+- Recommendations: [Improvements]
+
+FINAL RECOMMENDATION:
+[Approve / Modify / Redesign] with reasoning
+```
+
+### Pattern: Security Audit
+
+**Use when:** Checking for security vulnerabilities
+
+**Template:**
+```
+ROLE: Security engineer performing audit
+
+TARGET:
+[Code, system, or architecture to audit]
+
+SECURITY FRAMEWORK:
+- OWASP Top 10
+- Authentication/Authorization
+- Data protection
+- Input validation
+- Cryptography
+- API security
+- Dependency security
+
+THREAT MODEL:
+- Assets: [What needs protection]
+- Threat actors: [Who might attack]
+- Attack vectors: [How they might attack]
+
+OUTPUT:
+For each vulnerability:
+### [Vulnerability Name]
+- **CVSS Score**: [0-10]
+- **Category**: [OWASP category]
+- **Location**: [Where found]
+- **Description**: [What's vulnerable]
+- **Exploit scenario**: [How to exploit]
+- **Impact**: [Damage if exploited]
+- **Remediation**: [How to fix]
+- **References**: [CVE, CWE numbers]
+
+EXECUTIVE SUMMARY:
+- Critical vulnerabilities: [count]
+- Overall risk: [High/Medium/Low]
+- Priority fixes: [top 3]
+```
+
+---
+
+## Content Creation Patterns
+
+### Pattern: Technical Documentation
+
+**Use when:** Writing docs for APIs, libraries, tools
+
+**Template:**
+```
+ROLE: Technical writer with [domain] expertise
+
+DOCUMENTATION TARGET:
+[What you're documenting]
+
+AUDIENCE:
+- Experience level: [Beginner/Intermediate/Advanced]
+- Background: [Assumed knowledge]
+- Goals: [What they want to achieve]
+
+DOCUMENTATION REQUIREMENTS:
+- Tone: [Professional/Friendly/Formal]
+- Detail level: [High-level/Detailed/Comprehensive]
+- Include: [Examples/Diagrams/Code samples]
+
+STRUCTURE:
+# [Title]
+
+## Overview
+[One paragraph - what is it]
+
+## Quick Start
+[Minimal example to get started]
+
+## Installation
+[How to install/setup]
+
+## Core Concepts
+[Key ideas to understand]
+
+## Usage
+### [Feature 1]
+[Description + example]
+
+### [Feature 2]
+[Description + example]
+
+## API Reference
+[Detailed API docs]
+
+## Advanced Usage
+[Complex scenarios]
+
+## Troubleshooting
+[Common issues and solutions]
+
+## FAQ
+[Frequently asked questions]
+```
+
+### Pattern: Tutorial Creation
+
+**Use when:** Teaching how to do something step-by-step
+
+**Template:**
+```
+ROLE: Expert teacher creating a tutorial
+
+TUTORIAL GOAL:
+Teach [audience] how to [accomplish task]
+
+AUDIENCE:
+- Current knowledge: [What they know]
+- Learning goal: [What they'll learn]
+- Preferred style: [Hands-on/Conceptual/Both]
+
+TUTORIAL STRUCTURE:
+## Introduction
+- What you'll build
+- What you'll learn
+- Prerequisites
+
+## Concepts
+[Key ideas explained simply]
+
+## Step-by-Step Instructions
+### Step 1: [First step]
+- Explanation: [Why this step]
+- Code: [What to write]
+- Result: [What happens]
+
+### Step 2: [Next step]
+[Same format]
+
+## Challenges
+[Optional exercises]
+
+## Next Steps
+[Where to go from here]
+
+REQUIREMENTS:
+- Clear explanations for each step
+- Working code at each checkpoint
+- Expected output shown
+- Common mistakes highlighted
+```
+
+### Pattern: Blog Post/Article
+
+**Use when:** Writing technical articles or posts
+
+**Template:**
+```
+ROLE: Technical blogger writing for [audience]
+
+ARTICLE TOPIC:
+[What you're writing about]
+
+ARTICLE GOALS:
+- Educate about: [Topic]
+- Show how to: [Practical application]
+- Inspire to: [Action reader should take]
+
+REQUIREMENTS:
+- Length: [Word count]
+- Tone: [Conversational/Professional/Academic]
+- Include: [Code examples/Diagrams/Screenshots]
+- SEO keywords: [Primary and secondary]
+
+STRUCTURE:
+# [Compelling Title with Keyword]
+
+## Introduction (Hook)
+- Problem statement
+- Why it matters
+- What you'll learn
+
+## Background/Context
+[Necessary foundation]
+
+## Main Content
+### [Section 1]
+[Content with examples]
+
+### [Section 2]
+[Content with examples]
+
+### [Section 3]
+[Content with examples]
+
+## Practical Example
+[Working code or demo]
+
+## Conclusion
+- Summary of key points
+- Call to action
+- Further reading
+
+STYLE GUIDELINES:
+- Use "you" (second person)
+- Active voice
+- Short paragraphs (3-4 sentences)
+- Subheadings every 300 words
+- Code examples well-commented
+```
+
+---
+
+## Data Processing Patterns
+
+### Pattern: Data Extraction
+
+**Use when:** Pulling structured data from unstructured sources
+
+**Template:**
+```
+ROLE: Data engineer extracting information
+
+SOURCE DATA:
+[Unstructured text, logs, documents]
+
+EXTRACTION SCHEMA:
+{
+  "field1": "type (description)",
+  "field2": "type (description)",
+  "nested": {
+    "field3": "type"
+  }
+}
+
+EXTRACTION RULES:
+- If field not found: [default value or null]
+- Date format: [ISO 8601 / custom]
+- Number format: [decimal places, units]
+- Validation: [rules for valid data]
+
+OUTPUT FORMAT:
+Return JSON array of objects matching schema
+
+HANDLING AMBIGUITY:
+- Multiple possible values: [take first / all / ask]
+- Unclear data: [skip / estimate / flag]
+- Missing data: [null / default / omit]
+```
+
+### Pattern: Data Transformation
+
+**Use when:** Converting data from one format to another
+
+**Template:**
+```
+ROLE: Data transformation specialist
+
+INPUT DATA:
+[Current format]
+
+INPUT SCHEMA:
+[Structure of input]
+
+OUTPUT SCHEMA:
+[Desired structure]
+
+TRANSFORMATION RULES:
+1. [Field mapping]
+2. [Calculations]
+3. [Aggregations]
+4. [Filtering]
+
+EDGE CASES:
+- Missing values: [How to handle]
+- Invalid data: [How to handle]
+- Duplicates: [Keep / remove / aggregate]
+
+OUTPUT:
+Transformed data in target format
+```
+
+### Pattern: Data Analysis
+
+**Use when:** Analyzing datasets for insights
+
+**Template:**
+```
+ROLE: Data analyst
+
+DATASET:
+[Data to analyze]
+
+ANALYSIS OBJECTIVES:
+1. [What to discover - trends]
+2. [What to measure - metrics]
+3. [What to compare - segments]
+
+ANALYSIS FRAMEWORK:
+- Descriptive statistics (mean, median, distribution)
+- Trend analysis (over time)
+- Comparative analysis (between groups)
+- Correlation analysis (relationships)
+- Anomaly detection (outliers)
+
+OUTPUT STRUCTURE:
+## Executive Summary
+[2-3 sentences of key findings]
+
+## Key Metrics
+| Metric | Value | Change | Trend |
+
+## Detailed Analysis
+### [Finding 1]
+- Data: [Numbers]
+- Insight: [What it means]
+- Implication: [Why it matters]
+
+### [Finding 2]
+[Same structure]
+
+## Recommendations
+1. [Action based on findings]
+2. [Action based on findings]
+
+## Methodology
+[How analysis was performed]
+```
+
+---
+
+## Decision Support Patterns
+
+### Pattern: Technology Selection
+
+**Use when:** Choosing between technology options
+
+**Template:**
+```
+ROLE: Technical architect evaluating options
+
+DECISION CONTEXT:
+[What you're building, constraints, goals]
+
+OPTIONS:
+1. [Option A]
+2. [Option B]
+3. [Option C]
+
+EVALUATION CRITERIA:
+- Technical fit (how well it solves problem)
+- Team expertise (learning curve)
+- Community/support (help available)
+- Maturity/stability (production-ready?)
+- Performance (speed, efficiency)
+- Cost (licensing, infrastructure)
+- Maintenance (ongoing effort)
+- Scalability (future growth)
+
+ANALYSIS:
+For each option, evaluate against each criterion
+
+COMPARISON MATRIX:
+| Criterion | Weight | Option A | Option B | Option C |
+|-----------|--------|----------|----------|----------|
+
+RECOMMENDATION:
+- First choice: [Option] because [reasoning]
+- Alternative: [Option] if [conditions]
+- Avoid: [Option] because [reasoning]
+
+IMPLEMENTATION PLAN:
+[Next steps if recommendation accepted]
+```
+
+### Pattern: Problem Solving
+
+**Use when:** Working through complex problems
+
+**Template:**
+```
+ROLE: Problem-solving expert
+
+PROBLEM STATEMENT:
+[Clear description of the problem]
+
+CONTEXT:
+- Current situation: [What exists now]
+- Constraints: [Limitations]
+- Success criteria: [What good looks like]
+
+PROBLEM-SOLVING APPROACH:
+1. **Understand**: Restate problem, identify root cause
+2. **Analyze**: Break down into components
+3. **Generate**: Brainstorm possible solutions
+4. **Evaluate**: Assess each solution
+5. **Decide**: Choose best approach
+6. **Plan**: Create action plan
+
+OUTPUT:
+## Problem Analysis
+[Root cause, contributing factors]
+
+## Possible Solutions
+1. [Solution A]
+   - Pros: [Benefits]
+   - Cons: [Drawbacks]
+   - Effort: [Low/Medium/High]
+
+2. [Solution B]
+   [Same format]
+
+## Recommended Solution
+[Which one and why]
+
+## Implementation Plan
+1. [Step 1]
+2. [Step 2]
+3. [Step 3]
+
+## Risk Mitigation
+[What could go wrong and how to handle]
+```
+
+---
+
+## Learning & Teaching Patterns
+
+### Pattern: Concept Explanation
+
+**Use when:** Explaining technical concepts
+
+**Template:**
+```
+ROLE: Expert teacher explaining [topic]
+
+CONCEPT TO EXPLAIN:
+[Technical concept]
+
+AUDIENCE:
+- Background: [What they know]
+- Learning goal: [What they need to understand]
+- Preferred learning style: [Visual/Hands-on/Theoretical]
+
+EXPLANATION STRUCTURE:
+## Simple Definition
+[One sentence explanation]
+
+## Why It Matters
+[Real-world relevance]
+
+## How It Works
+[Step-by-step breakdown]
+
+## Analogy
+[Relate to familiar concept]
+
+## Example
+[Concrete, runnable example]
+
+## Common Misconceptions
+[What people get wrong]
+
+## When to Use
+[Practical guidelines]
+
+## Further Learning
+[Next topics to explore]
+
+REQUIREMENTS:
+- No jargon without explanation
+- Build from simple to complex
+- Multiple examples
+- Visual aids if helpful
+```
+
+### Pattern: Code Explanation
+
+**Use when:** Explaining how code works
+
+**Template:**
+```
+ROLE: Code teacher explaining implementation
+
+CODE TO EXPLAIN:
+[Code snippet or file]
+
+EXPLANATION LEVEL:
+- Audience: [Beginner/Intermediate/Advanced]
+- Focus: [High-level/Detailed/Both]
+- Goal: [Understanding/Implementation/Both]
+
+EXPLANATION STRUCTURE:
+## Overview
+[What this code does in one sentence]
+
+## Purpose
+[Why this code exists, problem it solves]
+
+## How It Works
+[Step through the logic]
+
+## Line-by-Line Breakdown
+Line X: [What it does, why it's there]
+Line Y: [What it does, why it's there]
+
+## Key Concepts Used
+- [Concept 1]: [Brief explanation]
+- [Concept 2]: [Brief explanation]
+
+## Example Usage
+[How to use this code]
+
+## Edge Cases
+[Special scenarios handled]
+
+## Improvements
+[How it could be better]
+```
+
+---
+
+## Debugging & Troubleshooting Patterns
+
+### Pattern: Error Diagnosis
+
+**Use when:** Figuring out what's wrong
+
+**Template:**
+```
+ROLE: Expert debugger
+
+ERROR REPORT:
+- Error message: [Exact error]
+- When it occurs: [Circumstances]
+- Expected behavior: [What should happen]
+- Actual behavior: [What actually happens]
+
+CODE:
+[Relevant code]
+
+ENVIRONMENT:
+- Language/Runtime: [Version]
+- Dependencies: [Versions]
+- OS/Platform: [Details]
+- Recent changes: [What changed]
+
+DEBUGGING PROCESS:
+1. **Understand**: Interpret error message
+2. **Locate**: Find where error originates
+3. **Analyze**: Determine root cause
+4. **Verify**: Confirm diagnosis
+5. **Solve**: Propose fix
+
+OUTPUT:
+## Error Analysis
+[What the error means]
+
+## Root Cause
+[Why it's happening]
+
+## Location
+[Where in code]
+
+## Fix
+[Code changes needed]
+
+## Verification
+[How to test the fix]
+
+## Prevention
+[How to avoid in future]
+```
+
+### Pattern: Performance Optimization
+
+**Use when:** Making code faster or more efficient
+
+**Template:**
+```
+ROLE: Performance optimization expert
+
+PERFORMANCE ISSUE:
+[What's slow or inefficient]
+
+CURRENT METRICS:
+- Response time: [Current]
+- Throughput: [Current]
+- Resource usage: [CPU/Memory]
+- Target: [What you need]
+
+CODE/SYSTEM:
+[Code or architecture to optimize]
+
+PROFILING DATA:
+[Measurements, bottlenecks identified]
+
+OPTIMIZATION APPROACH:
+1. Identify hotspots
+2. Analyze algorithmic complexity
+3. Propose optimizations
+4. Estimate improvements
+5. Consider trade-offs
+
+OUTPUT:
+## Bottleneck Analysis
+[What's causing slowness]
+
+## Optimization Opportunities
+1. [Optimization 1]
+   - Current: O(n²)
+   - Proposed: O(n log n)
+   - Expected improvement: [X% faster]
+   - Trade-off: [Any downsides]
+   - Implementation: [Code changes]
+
+2. [Optimization 2]
+   [Same format]
+
+## Recommended Approach
+[Which optimizations to do, in what order]
+
+## Expected Results
+[Performance after optimization]
+```
+
+---
+
+## Pattern Combination
+
+### Multi-Pattern Workflow
+
+Often, you'll combine patterns:
+
+**Example: Full Feature Development**
+1. Use **Technology Selection** to choose stack
+2. Use **Feature Implementation** to build it
+3. Use **Code Review** to verify quality
+4. Use **Technical Documentation** to document it
+5. Use **Tutorial Creation** to teach others
+
+**Example: Problem Resolution**
+1. Use **Error Diagnosis** to find the issue
+2. Use **Problem Solving** to explore solutions
+3. Use **Bug Fix** to implement the fix
+4. Use **Code Explanation** to document the solution
+
+---
+
+## Quick Reference
+
+### Choosing a Pattern
+
+| Task | Pattern |
+|------|---------|
+| Building new code | Feature Implementation |
+| Improving code | Code Refactoring |
+| Fixing bugs | Bug Fix, Error Diagnosis |
+| Reviewing code | Code Review |
+| Evaluating design | Architecture Review |
+| Security check | Security Audit |
+| Writing docs | Technical Documentation |
+| Teaching concept | Concept Explanation, Tutorial |
+| Making decisions | Technology Selection, Problem Solving |
+| Analyzing data | Data Analysis |
+| Transforming data | Data Extraction, Data Transformation |
+| Speeding up code | Performance Optimization |
+
+### Customizing Patterns
+
+All patterns are templates. Customize by:
+- Adjusting sections for your needs
+- Adding domain-specific criteria
+- Changing output format
+- Combining multiple patterns
+- Simplifying for simpler tasks
+
+---
+
+**Remember:** These patterns are starting points. Adapt them to your specific needs, combine them creatively, and iterate based on results.