How do you give code review feedback that actually changes how someone writes code?
answer
- what you use review for, in one line
- separate blocking from optional
- the reason and the cost, not the rule
- third repeat moves off the thread
- how you know it worked
basics
~20 sProbes whether review is teaching or gatekeeping. Say what you use review for, separate blocking comments from optional ones, give the reason and the cost rather than the rule, and move a repeated comment off the thread into a conversation.
how to answer
5 beats- what you use review forOpen with your purpose in one line — catching what tests cannot, and spreading context — so everything after it has a reason. Keep this short; it is framing, not the answer.
- how you sort what you comment onDescribe your working taxonomy: blocking, question, preference, and what you simply let go. Naming what you deliberately do not comment on is as strong a signal as naming what you block.
- how a single comment is writtenGive an actual comment in your words: the observation, the cost, and a question. Contrast it briefly with the version you used to write. This is where the teaching signal lives.
- when it stops being a threadState your rule for escalating to a call or a pairing session — repetition, volume, or a design disagreement — and say what you fix in the environment so the comment is not needed again.
- how you know it workedClose with an example where someone's later code changed, or a number that moved. Reviewers who cannot cite evidence usually cannot distinguish being obeyed from being understood.
your answer
4 story prompts- Find a comment you rewrote after it was ignored, and bring both versions.
- Pick one thing you deliberately stopped commenting on and say why.
- Recall a review where you moved the conversation off the thread, and what triggered it.
- Name one person whose later code changed because of a comment you left.
draft and rehearse your own answer in a learn session
go deeper
Code review is where most engineers do their teaching, and it is also where tone damage happens invisibly. Interviewers use this to probe standards, empathy and judgement at once: what you consider worth blocking, how you phrase a correction to someone you cannot direct, and whether you notice when review has stopped teaching and started gatekeeping.
I treat review as teaching first and a net second, because the net is mostly automated anyway. So I sort every comment into three kinds and label them: blocking, question, and nit. If it is a nit and there are more than two of them, I delete them and leave one comment saying the file needs a formatter rule, not a reviewer. For a blocking comment I try to write it the way I would say it aloud, with the cost attached. On a component pack we were building for a grocery client, instead of "don't do fetch in the component", I wrote that the fetch here runs on every re-render, and that on the store locator page that had already been our second-largest source of client errors, so could we hang it off the loader we use elsewhere. That comment gets acted on; the first version gets argued with. My other rule is that the third time I write the same comment to the same person, I stop writing it. I did that with a contractor on the same build — we paired for forty minutes on the data-loading pattern, and I put an example in the pack's README, which was the real gap. Errors on the storefront went from 2.9% of pageviews to 0.8% that quarter, and I stopped writing that comment entirely.
The taxonomy plus the deleted nits show judgement about what review is for, and the rewritten comment demonstrates teaching rather than instructing. The escalation rule is what lifts it above a list of habits. Naming no evidence, or rewriting the contractor's code personally, would downlevel it.
At the agency I was responsible for frontend quality across six client pods, seventeen engineers, and the review problem was variance: two pods blocked on formatting, one approved anything that compiled. Neither was teaching anybody. I did three things. First, I wrote down what review is allowed to block on — correctness, data handling, anything another pod has to consume — and said explicitly that style is the formatter's job. That removed most of the arguments. Second, I asked reviewers to attach a cost to every blocking comment; if you cannot say what breaks, it is a question, not a block. Third, we put the good comments in the open: once a fortnight I posted one well-written review comment in the shared channel with the author's name on it, and I never posted a bad one, because correction goes in a private message. The hardest part was coaching two leads whose reviews were technically excellent and quietly discouraging. I sat with each of them, read three of their own threads back, and asked what they thought the author felt. One changed immediately; the other needed a second conversation and a month. Across the eleven live client sites, sessions hitting a client-side error dropped from 3.4% to 1.2% over two quarters, and the share of pull requests needing a second review round fell from just over a third to about one in nine.
Signal comes from treating review as a system with variance to be reduced, the explicit line on what may block, and the coaching of other reviewers rather than of authors. It would downlevel if the speaker had only described their own review habits, or had skipped the private correction of the two leads.
Talk about the reviews you write and receive: asking questions when you do not understand, keeping comments about the diff, and saying when something is a preference. Reviewing above your experience level is fine if you frame comments as questions.
This is your home ground. Show a working taxonomy of comment types, a rule for when a thread becomes a call, and at least one instance where your comment changed how a person wrote code afterwards rather than just changing one file.
Speak about review as a quality mechanism across a team: what you insist on blocking for, what you deliberately let through, how you keep review latency from becoming the bottleneck, and how you coach other reviewers who are too harsh or too soft.
Frame it as calibration across teams — shared expectations for what review is allowed to block, automation that removes taste debates from humans, and how you detect a review culture that is quietly driving people to stop shipping.
saying these in an interview costs you the question
- Treating review as a style contest with no distinction between blocking and preference
- Comments phrased as verdicts on the author rather than on the change
- Rewriting the code yourself instead of teaching, then calling it mentoring
- Dozens of nits on a change with a real design problem left unmentioned
- No mechanism for the same comment appearing on a fourth pull request
- Claiming you never leave critical comments because you do not want conflict
- What do you do when someone makes the same mistake for the third time?Say that the thread is the wrong medium at that point and describe moving it to a short call or pairing session, plus fixing whatever made the mistake easy — a lint rule, a template, a missing utility. Repeating a comment louder is the answer to avoid.
- How do you review code from someone much more experienced than you?Frame comments as questions about intent, keep them on the change rather than on their judgement, and be willing to be taught. Say explicitly that you still leave the comment; deferring silently because of seniority is what interviewers are checking for.
- How do you stop a review turning into a fifty-comment thread?Describe a cutoff: past a handful of substantive comments, you take it to a call and summarise the outcome back on the thread. Mention that a change that large is often a signal to talk about the design before the code.
- When do you approve something you would have written differently?Show a working line between correctness and taste. Approving with non-blocking notes is a strength if you can name what would have flipped it to blocking — data loss, a security hole, an interface others will have to live with.