AI Prompts for Code Review

Prompts for reviewing code, finding risks, improving readability, spotting test gaps, and reviewing pull requests.

Who These Prompts Are For

Developers, frontend and backend engineers, tech leads, and coding learners who want a strong first-pass review. These prompts help you review code, find risks and bugs, improve readability, spot test gaps, and summarize pull requests.

How to Use These Prompts

Copy any prompt into ChatGPT, Claude, Gemini, or another AI tool. Paste the code and replace placeholders like [language] and [purpose]. Don’t paste secrets or confidential code into consumer tools. Treat AI findings as a first pass, not the final word.

Code Review Prompts

Review a code snippet:

Review this [language] code. Purpose: [what it does]. 

[paste code]

Give me prioritized findings: bugs, edge cases, readability, error handling, and security concerns. For each: severity (high/medium/low), the issue, and a concrete fix. Be specific — point to the line or function.

Review for a specific concern:

Review this [language] code with a focus on [concern — performance / security / readability / error handling].

[paste code]

Only flag issues related to that concern, ranked by importance, each with a suggested fix. Ignore unrelated nitpicks.

Review against best practices:

Review this [language] code against common best practices and conventions for [framework/context].

[paste code]

Point out where it deviates from idiomatic [language] and why it matters, with the recommended approach for each. Note anything that's fine as-is so I don't over-refactor.

Risk Detection Prompts

Find bugs and edge cases:

Find bugs and unhandled edge cases in this [language] code:

[paste code]

For each: what input or situation triggers it, what goes wrong, and how to fix it. Think about empty/null inputs, boundaries, concurrency, and unexpected types. Rank by likelihood and impact.

Spot security issues:

Review this [language] code for security issues:

[paste code]

Look for things like injection, unsafe input handling, exposed secrets, missing validation, and unsafe defaults. For each: the risk, why it matters, and the fix. Flag if you'd want a security specialist to confirm.

Identify edge cases:

For this function, list the edge cases it should handle: [paste code or describe it].

Cover boundary values, empty/null/invalid inputs, large inputs, and error conditions. For each, note whether the current code handles it and what to add if not.

Refactoring Prompts

Improve readability:

Refactor this [language] code for readability without changing behavior:

[paste code]

Improve naming, structure, and clarity; reduce nesting; and add brief comments only where they help. Show the refactored version and explain the key changes. Keep the same functionality.

Suggest a cleaner approach:

Here's working but messy [language] code: [paste]. Purpose: [describe].

Suggest a cleaner design or approach. Explain the trade-offs, and only recommend a rewrite if it's genuinely worth it. If small tweaks suffice, say so.

Test Gap Prompts

Find test gaps:

Here's my [language] code and its current tests: [paste both].

Identify what's NOT covered: untested paths, edge cases, and error conditions. List the missing tests in priority order, and describe what each should verify.

Suggest tests for code:

Suggest tests for this [language] function: [paste].

Give me test cases covering normal use, edge cases, and error handling — each with the input and expected result. Use [test framework] if I specify one. Focus on the cases most likely to catch real bugs.

Pull Request Prompts

Summarize a pull request:

Summarize this code change for a pull request description: [paste diff or describe the change].

Output: a clear title, a short summary of what changed and why, notable implementation details, and anything reviewers should pay attention to. Concise and reviewer-friendly.

Review a pull request:

Review this pull request. Context: [what it's meant to do]. 

[paste diff]

Give prioritized feedback: correctness, edge cases, readability, tests, and anything risky. For each: severity and a suggested change. End with an overall recommendation (approve / request changes) and the reasoning.