Prompt Patterns Every Developer Should Know

Build a [component/function/system] that:
- Does [specific behavior]
- Handles [edge cases]
- Should work with [existing code/framework]
- Requirements: [constraints, performance goals, etc]

Build a React hook that:
- Fetches data from an API endpoint
- Retries up to 3 times on failure
- Returns loading, error, and data states
- Cancels requests if the component unmounts
- Works with the fetch API, not axios
Requirements: TypeScript, zero external dependencies beyond React

I'm getting this error:
[full error message and stack trace]

Context:
- This happens when [what triggers it]
- Related code: [paste relevant function or module]
- Expected behavior: [what should happen]

Environment: [Node 18 / Python 3.11 / etc]

I'm getting this error:

TypeError: Cannot read property 'map' of undefined
  at getUserList (src/services/userService.ts:24:15)
  at processRequest (src/api/handlers.ts:41:8)

Context:
This happens when I call the /users API endpoint.

Related code:
const getUserList = async (filters) => {
  const response = await fetch('/api/users')
  const data = await response.json()
  return data.users.map(u => u.name) // Line 24
}

Expected behavior: Should return an array of user names.

Environment: Node 18, using fetch API

Refactor this [function/component/module] to:
- [specific improvement, e.g., improve readability]
- [another goal, e.g., add TypeScript types]
- [constraint, e.g., keep the same API]

Current code:
[paste code]

Context: [why you want to change it, what's bothering you]

Refactor this function to:
- Use async/await instead of promises
- Add proper error handling
- Keep the same function signature and behavior

Current code:
function fetchUserData(userId) {
  return fetch(`/api/users/${userId}`)
    .then(res => res.json())
    .then(data => processUser(data))
    .catch(err => console.log(err))
}

Context: I'm migrating the codebase to async/await and need to add proper error handling instead of silent logging.

Review this [function/component/module] against these criteria:
- [criterion 1, e.g., performance]
- [criterion 2, e.g., readability]
- [criterion 3, e.g., security]

Code:
[paste code]

Context: [what this does, who uses it, any constraints]

Review this authentication function against these criteria:
- Security: Are there any vulnerabilities?
- Performance: Is there unnecessary overhead?
- Readability: Is the logic clear?

Code:
const authenticate = (username, password) => {
  const user = findUser(username)
  if (user && user.password === hashPassword(password)) {
    return createToken(user.id)
  }
  return null
}

Context: This handles login in a Node.js API. It's called on every request to /login.

Generate tests for this [function/component] with [testing framework].
Cover these scenarios:
- [happy path: normal case]
- [edge case 1]
- [edge case 2]
- [error case]

Code:
[paste code]

Target coverage: [line coverage percentage if you care]

Generate tests for this function with Jest.
Cover these scenarios:
- Valid input returns correct output
- Handles null/undefined input
- Throws on invalid type
- Works with edge case values (0, empty string, etc)

Code:
const calculateDiscount = (price, percentage) => {
  if (percentage < 0 || percentage > 100) throw new Error('Invalid')
  return price * (1 - percentage / 100)
}

Target coverage: 100% line coverage

Write [type of documentation] for this code.
Audience: [who will read this]
Include: [what should be explained]

Code:
[paste code]

Context: [why this exists, any non-obvious design choices]

Write a JSDoc comment for this function.
Audience: Junior developers using this API
Include: What it does, parameters, return value, example usage

Code:
const retryWithBackoff = (fn, maxRetries = 3, baseDelay = 1000) => {
  return async (...args) => {
    for (let i = 0; i < maxRetries; i++) {
      try {
        return await fn(...args)
      } catch (err) {
        if (i === maxRetries - 1) throw err
        await new Promise(r => setTimeout(r, baseDelay * Math.pow(2, i)))
      }
    }
  }
}

Context: This is a utility used in our API client to handle transient failures gracefully.