Best Cursor AI Prompts for Developers (2025)

I'm getting this error:

[Paste the full error message and stack trace here]

Here's the relevant code:

[Paste the function or block where the error occurs]

What I expected: [describe expected behavior]
What actually happens: [describe actual behavior]

Diagnose the root cause and fix it. Do not change the function signature or return type.

Fix this TypeScript type error without using `any` or `as unknown`:

[Paste the error message]

Relevant types:

[Paste the type definitions involved]

Code where the error occurs:

[Paste the code block]

Explain in one sentence why the type error occurs, then show the corrected code.

This async function has intermittent behavior — sometimes it returns the correct result, sometimes undefined or an empty object:

[Paste the async function]

The function is called with: [describe call context and arguments]

Check for: missing awaits, race conditions, Promise.all vs sequential execution, and unhandled rejections. Show the corrected version with an explanation of what was wrong.

Refactor ONLY the code between the comments below. Do not modify anything outside these markers.

// REFACTOR START
[Paste the code to refactor]
// REFACTOR END

Goal: [e.g., "eliminate the nested loop", "extract the validation logic into a named function", "replace callback pattern with async/await"]

Constraints:
- Keep the same function signature and return type
- Maintain existing behavior for all edge cases
- Do not add new dependencies

This code has a performance issue — it slows down significantly when the input array exceeds ~500 items:

[Paste the slow function]

Identify the O(n²) or repeated-computation pattern causing the bottleneck. Rewrite it to run in O(n) or O(n log n). Show a before/after comparison and briefly explain the complexity improvement.

Audit this file for dead code: unused variables, unreachable branches, parameters that are always undefined, and imports that are never referenced.

[Paste the file or function]

List each dead code item with the line number, then show the cleaned version. Do not change any logic — only remove unused code.

This React component is doing too much. Break it into smaller, focused components.

[Paste the component]

Rules:
- Each new component should have a single responsibility
- Pass props explicitly (no context unless it already exists in the codebase)
- Keep the same external API — the parent that renders this component should not need changes
- Name components after what they render, not what they do (e.g., UserAvatar not renderAvatar)

Show the decomposed components and the updated parent.

Write a TypeScript function with this exact signature:

```typescript
function [functionName](input: [InputType]): [ReturnType]
```

Input shape: [describe or paste the type/interface]
Output shape: [describe or paste the expected return shape]
Business logic: [describe what the function should do step by step]

Requirements:
- Strict TypeScript — no `any`, no non-null assertions unless necessary
- Handle null/undefined inputs explicitly (throw or return early — specify which)
- Add a JSDoc comment with one @example using realistic values

Generate a [Next.js API route / Express endpoint] for this operation:

Method: [GET/POST/PUT/DELETE]
Path: [/api/example]
Purpose: [describe what this endpoint does]

Request body/params: [describe shape and required vs optional fields]
Success response: [describe shape and HTTP status]
Error cases to handle: [list specific errors and their status codes]

Use Zod for input validation. Include proper TypeScript types. No comments — just clean, production-ready code.

Write a utility function that transforms data based on these examples:

Input → Output:
- [example 1 input] → [example 1 output]
- [example 2 input] → [example 2 output]
- [example 3 input] → [example 3 output]

Edge cases it must handle:
- [edge case 1]
- [edge case 2]

Language: TypeScript. Return only the function — no tests, no usage examples.

Write a complete Jest test suite for this function:

[Paste the function]

Cover these cases:
1. Happy path — normal input returns expected output
2. Edge cases: [list specific ones, e.g., empty array, zero, null]
3. Error cases: what should throw and with what message

Style requirements:
- Use describe/it blocks
- Arrange-Act-Assert pattern within each test
- Descriptive test names (it('returns empty array when input is null', ...))
- No mocking unless the function calls external APIs

Generate the tests, not a plan for tests.

Write React Testing Library tests for this component:

[Paste the component]

Test these scenarios:
1. Renders without crashing and shows expected initial content
2. User interaction: [describe the key interaction, e.g., button click, form submit]
3. Loading state (if async): shows skeleton/spinner while fetching
4. Error state: shows error message when API fails

Use userEvent over fireEvent. Mock API calls with jest.fn() returning resolved/rejected Promises. Follow the RTL philosophy — test behavior, not implementation.

Here is a function and its existing tests. Identify all the code paths that are not covered.

Function:
[Paste the function]

Existing tests:
[Paste the test file]

List each uncovered branch/condition with the line reference. Then write the missing test cases. Do not rewrite existing tests — only add new ones.

Write a JSDoc comment for this function:

[Paste the function]

Requirements:
- @param for each parameter with type and description
- @returns with type and what it represents
- @throws if the function can throw — what triggers it
- One @example with realistic values (not foo/bar)
- Keep the total comment under 10 lines
- Do not restate the function name — explain what a caller needs to know

Write a README section for this module/component:

[Paste a brief description of what it does, or paste the code]

Section should cover:
1. One-sentence summary of what it does
2. When to use it (and when NOT to — what's out of scope)
3. Minimal code example showing the most common use case
4. Props/parameters table (if applicable)

Audience: a new engineer joining the team who hasn't seen this code before.
Length: under 150 words. No installation instructions.

Audit the inline comments in this code. Remove comments that just restate what the code does ("increment counter", "return true"). Add comments only where the WHY is non-obvious: a workaround for a specific bug, a non-obvious invariant, or behavior that would surprise a reader.

[Paste the code]

Return the code with comments added, removed, or kept according to that rule. Do not change any logic.