# The code review that makes a new FDE need you less each week

> Label each comment blocking or not, give the reason and let the author choose the fix: the client stays protected and the newcomer learns faster.

Original: https://fdetimes.net/en/guides/code-review-mentoring-new-fdes/

Three weeks into the job, a new FDE submits their first pull request that touches real client data: a script that syncs orders from the client's API into a data warehouse. You open it and find 14 things you want to comment on. The client needs a trial run on Monday morning. Take this as a hypothetical, but a familiar one.

There are two well-worn shortcuts. You rewrite it yourself to save time, and next time the newcomer still has to wait for you. Or you leave 14 comments that all look equally serious, and they spend two days fixing everything from variable names to a bug that could corrupt the client's numbers, without knowing which ones actually matter.

For an FDE, review is both the last line of defense before code runs in the client's environment and a training channel that operates every day. How you write comments therefore has a direct effect on how quickly a newcomer becomes independent, and it is also a visible signal of your own ability to lead others.

## The right measure is how often they still need you

Google's code review guidelines state a secondary goal plainly: to improve the author's skills so that over time they need less and less review. A good review, in other words, is not measured only by the number of defects it catches. It is also measured by whether the same person's next PR has fewer points that need blocking.

That goal fits how FDE teams bring newcomers up to speed. According to FDE Academy's description of the first 90 days, early work is fenced off so that new hires make their mistakes where the risk is still contained, not on a flagship client.

The manager keeps close supervision, but not to the point of suffocation. The milestone is the moment the newcomer can be given a real engagement without tight supervision.

Review is where that "close but not suffocating" supervision happens. The tension is that the client needs reassurance while the newcomer needs room to decide. The way through is to separate the two: what blocks a merge because it puts the client at risk, and what is simply a lesson.

## One PR, three kinds of comment

Back to the order sync script. Say the core looks like this:

```python
def sync_orders(since):
    orders = client.get("/orders", params={"since": since}).json()
    for o in orders:
        log.info(f"syncing {o}")
        db.execute(
            "INSERT INTO orders VALUES (%s, %s, %s)",
            (o["id"], o["email"], o["total"]),
        )
```

The code works in a demo. But it has two defects that would harm the client, one open question and a few purely cosmetic points. A good set of comments makes each category explicit:

```text
issue (blocking): If the job reruns after a network failure, the INSERT
will write duplicate orders and revenue on the client's dashboard will
be counted twice. We need a write that gives the same result no matter
how many times it runs. Which approach to use is your call.

issue (blocking): The log line prints the whole order, including the
end customer's email. Logs are usually read by more people and more
systems than the database. Log only the order id.

question (non-blocking): Does the client's API paginate? If so, this
function may only fetch the first page.

nit: Rename `o` to `order` for readability. Optional.
```

The "blocking" and "non-blocking" labels come from Conventional Comments, a convention that defines a blocking comment as one that prevents the PR from being accepted until it is resolved.

The authors of the convention argue that labeling saves hours of misunderstanding between reviewer and author. The "Nit" prefix comes from Google: a minor point that technically should be addressed but does not have much impact.

Three further details in the wording are worth noticing. Every comment is about the code ("the INSERT will write duplicate orders"), not the person ("you forgot to handle reruns"), in line with Google's principle of commenting on the code, never on the author.

Every comment carries a one-line reason, because the reason helps the author understand why you raised it and carry the principle into the next PR.

The third detail is subtler. On the duplicate-write bug, you point out the problem and let the author choose the fix; according to Google, this approach usually helps the author learn more.

On the logged email, you state the fix directly, because there is only one right answer and client data is no place for experiments. Knowing when to let a newcomer think it through and when to show the way is the hardest part of mentoring.

## When to hit approve

Now recount the original 14 points. Suppose that after sorting there are 2 blocking issues, 3 questions or suggestions, and 9 nits. The newcomer fixes the 2 blocking issues in an afternoon, answers the 3 questions, and the PR is merged before the end of the week; the 9 nits go into a later cleanup PR.

That is the approval standard Google recommends: favor approving a change once it definitely improves the overall health of the codebase, even if it is not perfect.

Reviewers look for continuous improvement, not perfection. For FDEs the standard carries an extra meaning: the client is protected exactly where the risk lies, and the newcomer is not held up where it does not.

## Same bug, different dose for each person

The article "Benevolent Code Reviews As a Busy Manager" on Crafting Tech Teams advises adjusting language and level of detail to the person or pair opening the PR.

For a newcomer in their first week, the comment on duplicate writes might run to three sentences, with an example of a job rerunning. By week six, the same issue needs only a question: "What happens if it runs twice?"

That short question is a sign of progress rather than laziness. You are moving judgment from your head into the newcomer's.

The same article stresses that review should educate, support and unblock, and that people do not learn when they feel judged. A string of harsh comments ahead of a client deadline is the fastest way to make a newcomer stop asking questions.

## Five steps for your next PR

**Step 1: identify the risk.** Before reading the first line of code, ask what the PR touches on the client side: real data, personal information, or only an internal tool. The answer tells you where to set the blocking threshold.

**Step 2: read everything before writing.** Go through the whole PR once before commenting, so you can sort by severity instead of commenting in line order.

**Step 3: write each comment to the template.** Each comment gets a label, addresses the code and gives a one-line reason; state the fix directly only when the risk to the client is high.

**Step 4: approve early.** Hit approve as soon as the blocking points are resolved, and push the nits to a cleanup PR.

**Step 5: track the trend.** Record the number of blocking comments on each PR from the person you are mentoring; if that number falls over the weeks, you are doing the job right.

## Common reviewer mistakes

The most common mistake is fixing it for them. It is fast today but slows down the whole quarter, because the newcomer never works through the reasoning on their own. The second is leaving every comment unlabeled, so the author treats a variable name and a data-loss bug the same way.

The third appears under client pressure: turning a nit into a blocker out of anxiety or, conversely, downgrading a security bug to non-blocking to make the demo. And the last is using one level of detail for everyone, long-winded with those already confident and curt with newcomers.

**Key point:** The best review for a newcomer is one that means they need you less next time.

The milestone FDE Academy describes for the first 90 days, when a newcomer is given a real engagement without tight supervision, is also a result worth putting on your CV if you are aiming for a senior or lead FDE role. Be specific: whom you mentored to that milestone, and which review conventions you brought to the team to help them get there.

In interviews, bringing a real comment you once wrote, labeled and with a reason, is usually more persuasive than generic self-descriptions of your leadership.

Good mentors measure their success by something rather counterintuitive: the day a newcomer's PR reaches you and there is nothing left to block.

**Try this week:**

- Take the last three PRs you reviewed, relabel every comment as blocking, non-blocking or nit, and count how many genuinely had to block the merge.
- On a new colleague's next PR, rewrite every comment about the person ("you forgot again...") as a comment about the code, with a one-line reason.
- Start recording the number of blocking comments on each PR from the person you are mentoring, so that in a few weeks you can see how the number has changed.

## Sources

- [How to write code review comments | eng-practices](https://google.github.io/eng-practices/review/reviewer/comments.html)

- [The Standard of Code Review | eng-practices](https://google.github.io/eng-practices/review/reviewer/standard.html)

- [Conventional Comments](https://conventionalcomments.org/)

- [Benevolent Code Reviews As a Busy Manager](https://craftingtechteams.substack.com/p/benevolent-code-reviews-as-a-busy)

- [Forward Deployed Engineer First 90 Days: What Actually Happens on the Job](https://fde.academy/blog/forward-deployed-engineer-first-90-days)
