skip to content

On a GitHub pull request, what is the difference between Approve, Request changes, and Comment?

level: juniorimportance: must knowfreq 75%

answer

  1. Three verdicts, one review object
  2. One of them carries an objection
  3. One carries no verdict at all
  4. Blocking comes from a repository rule
  5. Authors are limited on their own PR

basics

~20 s

Approve endorses the pull request and counts toward any required approvals. Request changes records a blocking objection that stays until the reviewer approves or the review is dismissed. Comment leaves feedback with no verdict either way.

solid answer

~40 s

When you submit a review on a GitHub pull request you pick one of three verdicts. **Approve** signs off; it counts toward a repository's required-approval rule. **Request changes** records an explicit objection — it stays attached to you as the reviewer until you submit a new approving review or someone with write access dismisses it. **Comment** attaches your notes with no verdict, which is the right choice for questions, observations, or a partial pass. Two details matter. A requested-changes review **hard-blocks the merge only when the repository requires approving reviews**; without such a rule GitHub shows the objection prominently but the merge button still works for someone with write access. And you cannot approve or request changes on your **own** pull request — the only review you may submit there is Comment.

code

json · 5 lines
json
[
  { "user": { "login": "maria" }, "state": "APPROVED" },
  { "user": { "login": "omar" }, "state": "CHANGES_REQUESTED" },
  { "user": { "login": "lin" }, "state": "COMMENTED" }
]

go deeper

for a junior

Recall the three verdicts and pick correctly: approve when you are happy for it to merge, request changes for something genuinely wrong, comment for questions. Remember you cannot approve your own pull request.

for a middle

Explain that a review is a stateful object and that blocking comes from the repository's required-review rule rather than from the button, and describe why batching comments into one submitted review beats posting them one at a time.

for a senior

Show judgment about when an objection is warranted and how you phrase an exit condition, plus how you keep a stale changes-requested state from silently parking a pull request for days.

for a principal

Own the norms: what the team agrees is blocking versus advisory, how you keep the changes-requested state credible rather than routine, and how review verdicts interact with the repository rules you have chosen to enforce.

## A review is an object, not a comment On GitHub, individual remarks on the diff are **review comments**, and a **review** is the container you submit them in, carrying one of three states: `APPROVED`, `CHANGES_REQUESTED`, or `COMMENTED`. (Two more states exist in the API: `PENDING` for a review you are still drafting, and `DISMISSED` for one that has been set aside.) Understanding that a review is a stateful object is what makes the rest of the behaviour predictable. ## The three verdicts **Approve** is a sign-off. If the repository requires a number of approving reviews before merging, yours counts toward it. Approving is not a claim that the code is perfect; it is a claim that you are content for it to merge, which is why approving while leaving non-blocking notes is normal and healthy. **Request changes** is an objection with teeth. It records that you, specifically, want something changed. It persists until one of two things happens: you submit a new review that approves, or someone with write access **dismisses** it with a stated reason. Notably, pushing new commits does not automatically clear it — the author fixing the problem does not retract your objection, and re-requesting your review is the normal next step. **Comment** submits your remarks with no verdict. Use it for questions, for context, for a partial review ("I looked at the migration only"), and for the case where you have opinions but no objection. It neither blocks nor unblocks anything. ## Blocking is a repository policy, not a property of the button The frequent misconception is that Request changes freezes the pull request. What it does on its own is make the objection loudly visible. The **merge** is blocked only when the repository has a rule requiring approving reviews — then an outstanding changes-requested review from an eligible reviewer prevents the merge until it is resolved. In an unprotected repository, a colleague with write access can merge straight over your objection. The button is a signal; the rule is the enforcement. Knowing which is which is what separates "I have used GitHub" from "I understand GitHub". ## Submitting: single comments versus a batched review There are two ways to leave a line comment. **Add single comment** posts immediately and notifies the author right away. **Start a review** puts your comments in a pending state visible only to you; they stay pending until you hit Submit review and choose a verdict, at which point they are delivered together as one notification. Batching is almost always the better behaviour. It spares the author fifteen separate notifications, it lets you revise or delete a comment when the next file explains what you were confused about, and it means the author sees the whole picture before starting to respond — rather than fixing your first three notes while you are still writing the one that says the approach should change. ## Reviewing your own pull request GitHub does not let an author approve or request changes on their own pull request; only Comment is available. This exists so required approvals mean something. Practically, authors should still use it: self-reviewing the diff before requesting review, and leaving comments that explain a non-obvious choice, measurably reduces round trips. ## Choosing a verdict well Approve when you are willing for it to merge, and say which of your remarks are optional. Request changes when something is genuinely wrong — a correctness bug, a security problem, a contract break — and say plainly what would satisfy you, because an objection without an exit condition is what makes review feel adversarial. Comment when you have questions, when the review is partial, or when the decision is not yours to gate. The verdict is also a social signal, and the two failure modes are symmetric: requesting changes over a naming preference teaches people that the state is noise, while approving code you believe is broken because you do not want conflict is how defects reach production with a green checkmark next to them.

  • Does pushing new commits clear an outstanding "Request changes" review?
    No. The changes-requested state stays attached to that reviewer until they submit an approving review or someone with write access dismisses it with a reason. The author's normal move after pushing a fix is to re-request review, which puts the reviewer back into a pending state and notifies them. Repositories can additionally dismiss stale *approvals* on a new push, but that is a different rule and it targets approvals.
  • What is the difference between "Add single comment" and "Start a review" on GitHub?
    A single comment posts immediately and notifies the author right away. Starting a review holds your comments in a pending state that only you can see until you submit the review with a verdict, delivering them as one notification. Batching is preferable: the author sees the whole picture at once, and you can still revise or drop a comment before submitting.
  • Can the author of a GitHub pull request approve it?
    No — on your own pull request the only review verdict available is Comment. This keeps required approvals meaningful. Authors should still use the self-review pass: reading your own diff on GitHub before requesting review catches debug statements and accidental files, and leaving comments that explain a non-obvious decision saves an entire round trip.

saying these in an interview costs you the question

  • Thinks Request changes always blocks the merge
  • Believes a new push clears requested changes
  • Uses Request changes for style preferences
  • Posts every note as a separate immediate comment
  • Assumes authors can approve their own pull request

context