AI Prompts for Developers — Copy & Paste

Explain what this TypeScript code does, step by step. Then list:
1. Inputs and outputs
2. Side effects (network, files, state)
3. Edge cases it does not handle

```
[paste code]
```

Asking for side effects and missing edge cases turns a summary into a review.

I am new to this React project. Based on the file tree and the files below, explain the architecture: the main modules, how data flows from a request to the response, and where I should look to change [feature].

File tree:
[paste tree]

Key files:
[paste files]

Break this down token by token and give three example inputs that match and three that do not:

[paste regex or command]

This TypeScript function should [expected behavior] but instead [actual behavior].

```
[paste code]
```

Find the root cause. Explain why it happens before proposing a fix, and show the smallest change that fixes it.

Describing expected vs actual behavior is the single biggest improvement to debugging prompts.

I get this error when [what you did]:

```
[paste error and stack trace]
```

Relevant code:
```
[paste code]
```

Explain what the error means, the most likely causes in order of probability, and how to confirm each one.

This TypeScript code takes [time] for [input size]. Identify the bottlenecks, estimate their complexity, and suggest optimizations ordered by impact vs effort. Do not change behavior.

```
[paste code]
```

I am stuck on [problem]. Do not give me the answer yet. Ask me one question at a time to help me find the cause myself.

Good when you want to learn rather than just get a fix.

Write a TypeScript function that [does X].

Requirements:
- [requirement]
- [requirement]

Handle these edge cases: [empty input, invalid values, …]. Use no external libraries. Add brief comments only where the logic is not obvious, and include example usage.

Create a React component in TypeScript for [describe UI]. Props: [list]. It must be accessible (keyboard, ARIA where needed) and responsive. Keep styling minimal and separate from logic.

Write a PostgreSQL query that [goal].

Schema:
```sql
[paste CREATE TABLE statements]
```

Explain the query, mention which indexes it needs, and point out anything that could be slow on large tables.

Convert this code from [source language] to TypeScript. Keep the same behavior, use idiomatic TypeScript rather than a line-by-line translation, and list any behavior that cannot be preserved exactly.

```
[paste code]
```

Write a bash script that [goal]. It must: exit on errors (set -euo pipefail), print what it is doing, accept [arguments] with a --help message, and be safe to run twice.

Review this code as a senior TypeScript engineer. Group findings by severity (bug, security, performance, readability). For each, quote the line, explain the problem and suggest a fix. Skip praise and nitpicks about formatting.

```
[paste diff or code]
```

Refactor this code for readability and maintainability without changing its behavior or public API. Explain each change in one line. Point out anything you were unsure was behavior-preserving.

```
[paste code]
```

Audit this code for security issues: injection, XSS, auth and access control, secrets, unsafe deserialization, SSRF and input validation. For each finding give a concrete exploit scenario and a fix.

```
[paste code]
```

This works but feels too complicated. Show a simpler version with fewer branches and less state, and explain what made the original complex.

```
[paste code]
```

Write Vitest unit tests for this TypeScript code. Cover the happy path, edge cases and error handling. Use descriptive test names, no shared mutable state, and mock only external dependencies.

```
[paste code]
```

Here is a function and its tests. List the important cases the tests do not cover, then write tests for the three most valuable ones.

Code:
[paste code]

Tests:
[paste tests]

Generate [number] realistic test records as JSON for this schema. Include tricky values: unicode names, very long strings, empty optional fields, boundary numbers and dates around DST changes.

[paste schema or type]

Write a conventional commit message for this diff: a subject line under 72 characters in the imperative mood, a blank line, then a short body explaining why the change was made.

```diff
[paste git diff --staged]
```

Get the diff with git diff --staged.

Write a pull request description for these changes with sections: Summary, Why, How it works, How to test, Risks. Keep it concise.

[paste diff or list of changes]

Add TypeScript doc comments (JSDoc/TSDoc, docstrings or equivalent) to this code: purpose, parameters, return value, errors thrown and one example. Do not change the code.

```
[paste code]
```

Write the "Getting started" section of a README for this project: prerequisites, installation, configuration (environment variables), running locally and running tests. Use copy-pasteable commands.

Project details:
[paste package.json / notes]

Explain this technical issue to a non-technical stakeholder in under 120 words: what happened, the impact on users, and what we are doing about it. No jargon.

[paste incident notes]

I need to [goal] in a React app. Compare [option A], [option B] and [option C] in a table: complexity, performance, maintenance, cost and when each is the best choice. Then recommend one for my situation: [context].

Design a PostgreSQL schema for [domain]. Entities: [list]. Show CREATE TABLE statements with keys, constraints and indexes, and explain how it supports these queries: [queries].

Break this feature into small tasks of at most half a day each, in a sensible order, with acceptance criteria for each:

[describe feature]

Review this REST API design for consistency, naming, status codes, pagination, error format, versioning and security. Suggest concrete improvements.

[paste endpoints or OpenAPI spec]