Use ChatGPT to Review Code for Obvious Issues

Code review by a teammate is the gold standard, but sometimes you are the only one awake, the pull request is small, or you just want a fast sanity check before you push. ChatGPT can fill that gap if you tell it what to look for. The problem is that most people paste code and say review this, which gets a polite but useless reply.

A better approach is to name the kind of issues you care about. Tell ChatGPT to check for off by one errors, null cases, unclear variable names, or missing validation. When you narrow the scope, ChatGPT stops writing a generic essay and starts reading the code like a reviewer with a checklist.

What a focused code review request looks like

A focused request has three parts. First, the code. Second, the review scope, meaning the kinds of problems you want caught. Third, the format for the feedback, such as a numbered list with line references. Without the scope, ChatGPT treats every line as equally interesting and the reply becomes noise.

When to use ChatGPT for a code review

• You are working alone and want a second pair of eyes before merging
• The change is small and a full team review feels heavy
• You want to catch surface bugs before the real reviewer sees the code
• You are learning a new language and want to know if your patterns are off
• You finished a late night session and want a morning sanity check

Prompt for reviewing a utility function

Code (utils/parse.ts):
export function parseAge(input: string): number {
  const num = parseInt(input);
  return num;
}

Review scope: edge cases, invalid input handling, type safety.
Format: numbered list. Each item names the issue and suggests one fix.
Do not rewrite the function. Only list issues.

Why this prompt works

The scope limits the review to edge cases and input handling. ChatGPT will notice that parseInt without a radix can produce surprises, that the function has no check for NaN, and that an empty string silently returns NaN. Without the scope, the reply might wander into naming conventions or style opinions that you did not ask about.

Prompt for reviewing an API route handler

Code (routes/orders.js):
app.post('/orders', async (req, res) => {
  const { userId, items } = req.body;
  const order = await Order.create({ userId, items, status: 'pending' });
  await sendConfirmation(userId);
  res.json({ orderId: order.id });
});

Review scope: input validation, error handling, security.
Format: numbered list with severity (low, medium, high) for each item.
Skip style and naming feedback.

Prompt for reviewing a React component

Code (ProfileCard.tsx):
function ProfileCard({ user }) {
  return (
    <div>
      <img src={user.avatar} />
      <h2>{user.name}</h2>
      <p>{user.bio}</p>
    </div>
  );
}

Review scope: missing prop handling, accessibility, rendering when data is incomplete.
Format: table with columns: issue, location, suggested fix.
Only include issues visible in this code.

What to include in your review request

• The full code block you want reviewed
• The language and framework if they are not obvious from the code
• Two to four categories of issues to check for
• The format you want feedback in, such as a list or a table
• A note to skip areas you do not care about, such as style or naming

How to refine the review

Pick one issue from the list and ask ChatGPT to expand on it. For example, item two mentions missing validation. Can you show what that validation would look like in this handler. Working issue by issue keeps the conversation focused and avoids a giant rewrite that mixes fixes together.

Common mistakes

• Sending code with no review scope so the reply covers everything shallowly
• Asking for a review and a rewrite in the same message
• Pasting hundreds of lines when only one function matters
• Trusting the review as final without reading the code yourself
• Skipping the format instruction so the feedback comes back as a wall of text

How to check the review before you act

Pick the two highest severity items and verify them in the code. If ChatGPT says there is no check for null on line three, open line three and confirm. If those two hold up, the rest of the list is worth reading. If either is wrong, tighten the scope and ask again.

Takeaway

A code review from ChatGPT is not a replacement for a teammate, but it is a fast way to catch the obvious things before the real review starts. Name the scope, set the format, and treat the output as a checklist.