ChatGPT Prompts for Coding That Actually Work

Please review the following [language] code and provide feedback across these dimensions:
1. Correctness — any bugs, edge cases, or off-by-one errors
2. Performance — any bottlenecks, unnecessary allocations, or O(n²) patterns
3. Readability — naming, structure, comment quality
4. Security — any injection risks, exposed secrets, or unsafe operations
5. Best practices — adherence to [language/framework] conventions

Code:
[paste your code here]

Format your response as a numbered list under each dimension heading. Flag critical issues separately.

I have a bug in my [language] code and I need help debugging it systematically.

**What the code is supposed to do:**
[describe expected behavior]

**What it actually does:**
[describe actual behavior, including any error messages]

**What I've already tried:**
[list any debugging steps you've taken]

**Relevant code:**
[paste the suspicious section]

Please walk me through likely root causes, starting with the most probable. For each hypothesis, tell me exactly how to verify or rule it out.

Refactor the following [language] code to improve readability and maintainability without changing its behavior.

Goals:
- Extract magic numbers and strings into named constants
- Break long functions into smaller, single-responsibility functions
- Improve variable and function names to be self-documenting
- Remove redundant comments while adding clarifying ones where logic is non-obvious
- Apply [language] idiomatic patterns where appropriate

Original code:
[paste code here]

Show me the refactored version with a brief explanation of each significant change you made.

Write comprehensive unit tests for the following [language] function using [testing framework, e.g., Jest/Pytest/Go testing].

Function to test:
[paste your function]

Cover these test cases:
1. Happy path — expected inputs producing expected outputs
2. Edge cases — empty input, null/undefined, zero, empty array, maximum values
3. Error cases — invalid types, out-of-range values, and expected exceptions
4. Boundary conditions specific to this function's logic

Format each test with a descriptive name following the pattern: "should [do X] when [condition Y]". Include setup and teardown where needed.

Explain the following [language] code to me as if I'm a [junior developer / senior developer unfamiliar with this library / non-technical stakeholder].

Code:
[paste code here]

Please cover:
1. What this code does at a high level (2-3 sentences)
2. A line-by-line or block-by-block walkthrough of the key logic
3. Any non-obvious patterns, design choices, or gotchas
4. What would break if I removed or changed [specific part of the code]

Review the following REST API design and suggest improvements.

API specification:
[paste your endpoint list, request/response shapes, or OpenAPI spec]

Evaluate the design against these criteria:
1. RESTful conventions — proper use of HTTP verbs, status codes, and resource naming
2. Consistency — naming conventions, response envelope structure, error format
3. Versioning strategy — is it future-proof?
4. Security — authentication, authorization, rate limiting considerations
5. Developer experience — is this intuitive for a new API consumer?

Provide a revised version of any endpoints that need changes, with a rationale for each change.

Optimize the following SQL query for performance. The database is [PostgreSQL / MySQL / SQLite / SQL Server].

Current query:
[paste your SQL]

Table schema and indexes:
[paste CREATE TABLE statements and existing indexes]

Approximate row counts: [table_name]: [row count], [table_name]: [row count]

Please:
1. Identify the performance bottlenecks (e.g., full table scans, missing indexes, N+1 patterns)
2. Rewrite the query with optimizations applied
3. Suggest any indexes that should be created
4. Explain the expected performance improvement for each change

Write a regular expression that matches the following pattern in [language/flavor, e.g., JavaScript, Python re, PCRE].

Pattern to match:
[describe what you need to match, e.g., "US phone numbers in formats like (555) 867-5309, 555-867-5309, and 5558675309"]

Requirements:
- Must match: [list valid examples]
- Must NOT match: [list invalid examples that might look similar]
- [Any additional constraints: anchored to line, case-insensitive, etc.]

Provide:
1. The regex with explanation of each group/token
2. A code snippet showing how to use it in [language]
3. Any known edge cases where it might fail

Write API documentation for the following [language] function/class/module.

Code:
[paste your code]

Generate documentation in [JSDoc / Python docstring / Go doc comment / Markdown] format that includes:
1. A one-sentence summary
2. Detailed description of what it does and when to use it
3. Parameters table with name, type, required/optional, and description
4. Return value description with type
5. At least 2 concrete usage examples showing real-world scenarios
6. Notes on any known limitations, side effects, or important behavior

Help me migrate the following code from [old technology/version] to [new technology/version].

Current code ([old technology]):
[paste your code]

Migration goals:
- Target: [new technology, e.g., "React class components to React hooks", "Python 2 to Python 3", "CommonJS to ES Modules"]
- Maintain identical behavior
- Apply modern patterns and best practices of the target
- Flag any functionality that doesn't have a direct equivalent

Provide:
1. The migrated code
2. A summary of every change made
3. Any manual steps I still need to take (e.g., package updates, config changes)

Help me design the right data structure for the following problem.

Problem description:
[describe what you need to store and what operations you need to perform]

Constraints:
- Expected data volume: [e.g., "~1 million records"]
- Most frequent operations: [e.g., "fast lookup by user ID, range queries by date"]
- Write vs. read ratio: [e.g., "90% reads, 10% writes"]
- Language/environment: [language and whether in-memory or persistent]

Please:
1. Recommend a data structure (or combination) with justification
2. Show a concrete implementation in [language]
3. Analyze time and space complexity for the key operations
4. Mention any trade-offs compared to alternative approaches

Perform a security audit on the following [language/framework] code and identify potential vulnerabilities.

Code:
[paste your code]

Application context:
- Type: [e.g., REST API, web app, CLI tool]
- Handles user data: [yes/no, what kind]
- Authentication method: [e.g., JWT, session cookies, API keys]
- External dependencies used: [list key libraries]

Check for:
1. Injection vulnerabilities (SQL, NoSQL, command injection, XSS)
2. Authentication and authorization flaws
3. Sensitive data exposure (hardcoded secrets, logging PII)
4. Insecure deserialization
5. Dependency vulnerabilities
6. Missing input validation and sanitization

Rate each finding as Critical / High / Medium / Low with a code-level fix recommendation.