I need to [objective]. Here are the requirements:

**Tech Stack:** [languages, frameworks]
**Functionality:**
- [requirement 1]
- [requirement 2]

**Constraints:**
- [constraint 1]
- [constraint 2]

**Output Format:** [desired format]

Provide [level of detail].

I need to implement rate limiting for my API. Here are the requirements:

**Tech Stack:** Node.js, Express, Redis
**Functionality:**
- Limit to 100 requests per minute per IP
- Return 429 status when exceeded
- Include retry-after header

**Constraints:**
- Must work across multiple server instances
- Should be reusable middleware

**Output Format:** Complete Express middleware code with comments

Provide production-ready code with error handling.

You are a [role] with expertise in [domain].

[Context and situation]

[Specific question or task]

[Expected output format]

You are a senior DevOps engineer with 10 years of Kubernetes experience.

I'm seeing OOMKilled errors on my production pods. Here's my deployment:

[paste deployment.yaml]

Diagnose the issue and provide:
1. Root cause analysis
2. Immediate fix
3. Long-term solution
4. Monitoring recommendations

Think through this step by step:

1. First, [step 1]
2. Then, [step 2]
3. Finally, [step 3]

[Problem description]

Think through this step by step:

1. First, analyze what makes this query slow
2. Then, identify optimization opportunities
3. Finally, provide the optimized query

Query:
SELECT * FROM orders o
JOIN customers c ON o.customer_id = c.id
WHERE o.created_at > '2024-01-01'
ORDER BY o.total DESC

Database: PostgreSQL 15, 10M rows

Follow this pattern:

Example 1:
[input] → [output]

Example 2:
[input] → [output]

Now do the same for:
[new inputs]

Generate error handlers following this pattern:

Example 1:
NotFoundError → { status: 404, message: 'Resource not found' }

Example 2:
ValidationError → { status: 400, message: 'Invalid input', errors: [...] }

Now create handlers for:
- DatabaseError
- AuthenticationError
- RateLimitError

Project context:
- Type: [project type]
- Tech: [stack]
- Structure: [architecture]

Current state:
[describe current implementation]

Task:
[what you need to do]

Consider:
[specific constraints or preferences]

Project context:
- Type: E-commerce REST API
- Tech: Python FastAPI, PostgreSQL, Redis
- Structure: Microservices with event-driven architecture

Current state:
We have user authentication working with JWT tokens

Task:
Add password reset functionality

Consider:
- Must send reset emails asynchronously
- Token should expire in 1 hour
- Should rate-limit reset requests

[Previous output wasn't perfect]

Improve this by:
- [specific change 1]
- [specific change 2]
- [specific change 3]

[Context if needed]

The previous function doesn't handle edge cases.

Improve this by:
- Add null/undefined checks
- Handle empty arrays
- Add TypeScript type guards
- Include JSDoc comments

Maintain the same core logic.

Compare [option A] vs [option B] for [use case].

Consider:
- [criterion 1]
- [criterion 2]
- [criterion 3]

Provide:
- Summary table
- Recommendation with reasoning

Compare PostgreSQL vs MongoDB for a social media application.

Consider:
- Scalability (expected 1M users)
- Query patterns (mostly reads, some complex joins)
- Development speed
- Cost at scale

Provide:
- Feature comparison table
- Recommendation with reasoning
- Migration complexity if we change later

I'm encountering [issue].

**What I'm trying to do:** [goal]
**What's happening:** [actual behavior]
**What I expected:** [expected behavior]

**Code:**
```[language]
[code snippet]

[exact error message]

---

## Pattern 9: Code Review Request

**When to use:** Getting feedback on code quality

**Template:**

[code]

**Example:**

def login(username, password):
    query = f"SELECT * FROM users WHERE username='{username}'"
    result = db.execute(query)
    return result.fetchone()

---

## Pattern 10: Test-Driven Prompt

**When to use:** Want implementation that matches specific tests

**Template:**

[test cases]

**Example:**

test('validates email format', () => {
  expect(isValidEmail('user@example.com')).toBe(true);
  expect(isValidEmail('invalid')).toBe(false);
});

test('rejects emails with special chars in domain', () => {
  expect(isValidEmail('user@exam!ple.com')).toBe(false);
});

---

## Quick Reference Table

| Pattern | Best For | Complexity | Output Quality |
|---------|----------|------------|----------------|
| Specification-First | New features | Low | ⭐⭐⭐⭐⭐ |
| Role-Based | Expert advice | Low | ⭐⭐⭐⭐ |
| Chain-of-Thought | Complex logic | Medium | ⭐⭐⭐⭐⭐ |
| Few-Shot Learning | Consistent format | Medium | ⭐⭐⭐⭐⭐ |
| Context Stacking | Project work | Medium | ⭐⭐⭐⭐ |
| Iterative Refinement | Improvements | Low | ⭐⭐⭐⭐ |
| Comparative Analysis | Decision making | Medium | ⭐⭐⭐⭐ |
| Debug Detective | Troubleshooting | Low | ⭐⭐⭐⭐⭐ |
| Code Review | Quality check | Low | ⭐⭐⭐⭐ |
| Test-Driven | TDD approach | High | ⭐⭐⭐⭐⭐ |

---

## Advanced Modifiers

Add these to any pattern for better results:

### Specificity Modifiers

### Format Modifiers

### Constraint Modifiers

### Output Control

---

## Common Mistakes to Avoid

### ❌ Too Vague

### ✅ Specific

---

### ❌ No Context

### ✅ With Context

---

### ❌ Accepting First Output

### ✅ Iterating

---

## Tool-Specific Tips

### ChatGPT / Claude
- Can handle longer, more detailed prompts
- Excels at explanation and teaching
- Good for multi-step tasks

**Example:**

### GitHub Copilot (IDE)
- Works best with comments above code
- Leverages context from open files
- Prefers concise, directive comments

**Example:**
```javascript
// Function that fetches user profile from API,
// caches in localStorage, expires after 1 hour,
// returns null on error
async function getUserProfile(userId) {

?? find all JavaScript files that import React but
   don't use hooks, exclude node_modules

Create a [METHOD] endpoint for [purpose] using [framework].

Route: [path]
Request: [body schema]
Response: [response schema]
Auth: [requirements]
Validation: [rules]

Include error handling and logging.

Write a [SQL/NoSQL] query to [purpose].

Database: [type, version]
Tables/Collections: [schema]
Performance: [requirements]

Optimize for [criterion] and explain indexes needed.

Refactor this to [goal]:

```[language]
[original code]

### Documentation

[code]

---

## Measuring Prompt Quality

Good prompts have:

✅ **Clear objective** - Know what you want  
✅ **Sufficient context** - Provide background  
✅ **Specific constraints** - Define boundaries  
✅ **Output format** - Specify structure  
✅ **Examples** (when helpful) - Show patterns  

Track your success rate:
- First-try success: aim for 80%+
- Iterations needed: aim for ≤2
- Time saved: measure against manual approach

---

## Pro Tips

**1. Build a personal prompt library**
Save prompts that work well for your common tasks.

**2. Start broad, then narrow**
First get a general solution, then refine with specifics.

**3. Use examples from your codebase**
Show the AI your coding style for consistent output.

**4. Iterate on prompts, not just outputs**
Improve the prompt for next time, not just this time.

**5. Combine patterns**
Mix and match for complex tasks:

---

## Resources

- [OpenAI Prompt Engineering Guide](https://platform.openai.com/docs/guides/prompt-engineering)
- [Anthropic Prompt Engineering](https://docs.anthropic.com/claude/docs/prompt-engineering)
- [Learn Prompting](https://learnprompting.org/)
- [Prompt Engineering Guide (DAIR.AI)](https://www.promptingguide.ai/)

---

*Last updated: November 21, 2025*