# The Reviewer-First Senior Slate: De-Botted Reviews to a Ranked Shortlist

*Turn a role brief into a ranked slate of 15 to 30 senior and staff engineers, each backed by one cited code review thread, in about two working days.*

- Canonical URL: https://www.refolk.ai/guides/reviewer-first-senior-engineer-slate
- Pillar: Recruiting and sourcing
- Format: Playbook
- Published: 2026-11-16
- Last reviewed: 2026-11-16
- Reading time: 22 min
- Keywords: how to find senior engineers on github, source engineers from code review activity, github reviewed-by search recruiting, sourcing staff engineers open source, filter ai bots from github contributors, github sourcing ai generated pull requests

## Key takeaways

- In one study of 16,650 code reviews across 9,645 repos, AI agents did 32% of the reviewing but approved only 2.0% of the time, so merge-gating approvals are the review signal agents pollute least.
- A bot filter that keys only on the [bot] suffix lets the bare Copilot login through, which files roughly a third of AI review activity as human.
- In Qt and OpenStack, 67 to 86% of developers never authored code in a module but still reviewed 21 to 39% of its changes, so author-based GitHub sourcing misses most of the people who judge the code.
- Only approvals from people with write access count toward required reviews, so a reviewer's score should weight approvals from CODEOWNERS or OWNERS listees and proven mergers, counted on human-authored PRs only.
- Refolk's index lists 3,191 Staff Kubernetes engineers in the US but only 333 in Germany, so a 30-person German slate uses 9% of the titled pool and reviewer evidence, not title, has to carry the level call.
- A full 12-month pull of a 3,000-PR repo costs about 6,030 core REST calls, roughly 1.2 hours on one personal access token, and the whole procedure fits in about two working days.

This playbook is for in-house recruiters, sourcers, and founders filling senior and staff engineering seats on a specific stack who no longer trust commit counts or contribution graphs to show who is good. It starts from the review side of GitHub, where judgment shows up as change requests, breadth across authors, and approvals that actually gate merges. Followed in order, it turns a role brief into a ranked slate of 15 to 30 humans, each backed by one cited review thread, in about two working days.

## Why source senior engineers from code review instead of commits?

Source from review because authorship signals now carry a lot of agent output, while the acts that mark senior judgment, blocking a flawed change or approving one so it can merge, are still overwhelmingly done by people. Review has its own AI noise, but you can measure and remove it in a way you cannot with commit density.

Three independent measures of AI in public code review:

| Source | Sample | AI share | AI approval rate |
|---|---|---|---|
| CodePulse | 16,650 reviews, 9,645 repos | 32% of reviews | 2.0% (3% where able to approve) |
| Pullflow | 40.3M PRs | 1.1% rising to 14.9% of PRs | Not reported |
| AIDev / NCU Toruń | 33,596 agent-authored PRs | 22.6% reviewed by AI only | Not reported |

Read the table in two directions. First, AI reviewers are common: about a third of review events in the CodePulse sample came from agents. Second, they almost never approve. Across the 3,598 agent reviews where approval was possible, the approval rate was 3%. Part of the low 2.0% overall figure comes from the fact that Copilot could not approve a pull request at all during that measurement window. Separately, Copilot's reviews do not count toward required human approvals for merging.

**32% - Share of public code review performed by AI agents in a 16,650-review study**

The same agents approved only 2.0% of the time, which is why approvals, not comments, anchor this method.

The second reason to start from review is that it surfaces people that author-based sourcing never sees. In studies of Qt and OpenStack, 67 to 86% of developers did not author any code changes for a module but still reviewed 21 to 39% of its changes. If you source from a module's contributor tab, you miss them. Research on reviewer-recommendation tools such as REVFINDER points the same way: recommendations built on review expertise beat those built on modification expertise. The field's own tooling trusts review history more than commit history to find who knows the code.

#### How much each GitHub signal can be inflated by agents

1. **Commits and contribution graphs** - Agent-authored PRs inflate volume directly; tells you activity, not judgment
2. **Review comments** - About a third of review events are agents; mostly COMMENTED state
3. **Change requests** - Rarer, formal, and must say what is wrong; humans can still paste agent text
4. **Merge-weight approvals on human-authored PRs** - Need write access; agents approve 2 to 3% of the time

*The further down the stack a signal sits, the harder it is for an agent to manufacture, so a reviewer-first score is built from the bottom up.*

## Which review signals show senior judgment?

Three signals carry the score: substantive change requests, the number of distinct authors a person reviews, and approvals that carry merge weight. Each one proves something different, and each one can mislead in its own way.

Two terms first. A **change request** is a review submitted with the formal state CHANGES_REQUESTED, as opposed to a plain comment. An approval carries **merge weight** when it counts toward the repo's required reviews. With required reviews on, a PR must be approved by the required number of reviewers with write permissions. When code-owner review is required, a PR touching owned paths must also be approved by a code owner, and code owners must have write permission.

| Signal | What it proves | How it lies | Check |
|---|---|---|---|
| Substantive change requests | Will block a flawed change and say why | Style nits, or agent-drafted text posted under a human login | Read the body and inline comments |
| Distinct authors reviewed | Trusted across the team, not one colleague's reviewer | Breadth built by rubber-stamping agent PRs | Count human-authored PRs only |
| Merge-weight approvals | The approval gated a real merge | Read-only or outside-contributor approvals, which protection ignores | Confirm CODEOWNERS/OWNERS listing or merged-by record |
| Review volume | Sustained engagement over the window | Bots and comment-only accounts | Compare to the Low and High bands below |

Treat approvals with one more caution. GitHub rulesets now require an additional approval for unattributed Copilot pull requests by default, so agent-authored PRs attract approvals that exist to satisfy a rule, not to show judgment. Score approvals on human-authored PRs separately from approvals on agent-authored ones, and rank only on the first.

For volume, one Cassandra study banded reviewer experience at 0 to 3.38 reviews per month as Low and 6.41 or more per month as High. That comes from a single project, so use it as a reference point to make sure you're not ranking someone off three reviews, not as a validated cut line.

### A workable rubric

Score each human 0 to 3 on each of the three core signals by where they fall in your own pool of reviewers across the target repos, then sum. Break ties on merge-weight approvals on human-authored PRs. Relative scoring keeps the rubric honest across repos of very different sizes. The weights are my judgment, not a published standard.

A change request is **substantive** when its body or its inline comments name a concrete problem in the code: correctness, API shape, concurrency, error handling, missing tests. A change request that only asks for formatting does not count.

#### Reading a reviewer from two signals

Horizontal axis runs from Few distinct authors reviewed to Many distinct authors reviewed. Vertical axis runs from Few substantive change requests to Many substantive change requests.

| Quadrant | What it means |
| --- | --- |
| Specialist gatekeeper | Keep if their paths match the role; level from the cited thread |
| Senior judgment across the codebase | Slate first; confirm merge-weight approvals |
| Drive-by reviewer | Drop unless an owner listing says otherwise |
| Broad approver, rarely pushes back | Check whether approvals are on agent PRs before keeping |

*Breadth without change requests is usually rubber-stamping, and change requests without breadth is usually a specialist, so neither quadrant ranks on one number.*

> **Rule:** Score per reviewer from the reviews endpoint, never from search
>
> Every score must come from review submissions that carry the reviewer's own login and state. Search qualifiers describe the pull request, so they can show a person was present but not what they did.

One limit to keep in front of you: no one has published a validated link between change-request share, author breadth, or comment length and job title or level. This rubric ranks judgment that is visible in public. It does not detect seniority. The level call in the final step is a human judgment, backed by a cited thread.

## How big is the pool behind a senior Kubernetes slate?

Size the pool before you choose repos. Supply decides how far down the rubric you will have to go and whether title can do any of the levelling work. In the index behind [Refolk](/), Staff Kubernetes engineers are plentiful in the US and scarce in Germany.

| Segment | Profiles | Metro share of 25-profile sample | Top employer in sample |
|---|---|---|---|
| Staff, US | 3,191 | 6/25 (24%), SF/Bay | Figure (3) |
| Staff, Germany | 333 | 12/25 (48%), Berlin | None repeated |
| Senior, Germany | 2,025 | 15/25 (60%), Berlin | Zalando (2) |

Derived from those counts:

- The US Staff pool is 9.6x the German one.
- In Germany, Senior-titled Kubernetes engineers outnumber Staff-titled ones 6.1 to 1.
- A 15 to 30 person slate is 4.5% to 9.0% of the German Staff pool, but only 0.5% to 0.9% of the US Staff pool.

**333 - Staff Software Engineers or Staff Engineers with Kubernetes in Germany, in Refolk's index**

A 30-name slate would use 9% of everyone carrying that title, against 0.9% in the US.

What this changes in practice:

- **In the US**, a slate is under 1% of the titled pool. You can keep the reviewer score strict and still fill 30 rows.
- **In Germany**, you will run out of Staff-titled reviewers quickly. Pull in Senior-titled people whose reviews read like staff work. With a Senior band 6.1x larger, the reviewer evidence, not the title, has to carry the level decision.
- **Titles in any index are mixed.** One profile in the German Staff sample carries the title "Prometheus Steering Committee Member", which is a project governance role, not an employer job title. Treat title as a hint.

The per-employer and per-metro breakdowns come from 25-profile samples. Use the totals for sizing and read the samples as illustrative only. You can run the same title, skill, and country question for your own stack before step 1. It takes minutes and tells you which side of this split you are on.

## The reviewer-first procedure, step by step

The procedure has eight steps and takes about 16 to 19 hours of sourcer and lead time plus a scripted pull, which fits into about two working days. No public source documents this whole process. It is assembled from documented components, and the time budgets are my working estimates, not measured benchmarks.

#### From role brief to ranked slate

1. **Pick 3 to 8 target repos** - Choose repos where the role's stack is the main language and that have a CODEOWNERS or OWNERS file. Done is a repo list with one line of reasoning per repo, about 2 hours.
2. **Read each repo's review governance** - Parse CODEOWNERS or OWNERS into a path-to-owner list and note any PR page showing the review-required state. Done is an owner list per path, about 1 hour.
3. **Pull every review in the dated window** - List all PRs created in the 12-month window, call the per-PR reviews endpoint for each, and store every submission. Done is one review-event file with latest state per user per PR derived, 2 to 3 hours of script wall time.
4. **Strip bots and agents** - Drop [bot] logins, type Bot accounts, the bare Copilot login, and the 12 agents named in the ESEM study, then flag never-approve, mostly-comment accounts. Done is a human reviewer list with a flag column, about 1 hour.
5. **Score the human reviewers** - Score substantive change requests, distinct authors reviewed, and merge-weight approvals on human-authored PRs only. Done is a ranked table with sub-scores visible, about 3 hours.
6. **Strike off-limits employers and set the cap** - The hiring lead strikes client and off-limits employers using declared affiliations and writes a numeric per-employer cap into the brief. Done is a filtered list and a written cap, about 1 hour.
7. **Resolve each current employer** - Confirm employer from profile, commit email domain, and org membership, requiring two to agree, then re-apply the cap. Done is an employer with evidence on every row, 4 to 6 hours.
8. **Level the names and ship the slate** - Pick one review thread per person that shows the scored judgment, write a one-line level read, and cut to 15 to 30 names. Done is a ranked slate where every row links to a review that person submitted, about 2 hours.

No source settles whether the off-limits and concentration pass should come before or after employer resolution. I split it. A cheap strike on declared affiliation comes first, so you don't spend resolution hours on people you cannot approach. The binding cap check comes after resolution, because declared affiliations are wrong often enough to matter.

## How do you pull and de-bot every review in a dated window?

List every PR in the window through the REST API, call the reviews endpoint once per PR, and keep every submission. Then remove bots and agents in several passes, because no single field catches them all. Search is for slicing and spot checks only.

### Pulling within API limits

The per-PR endpoint is `GET /repos/{owner}/{repo}/pulls/{number}/reviews`, at a maximum of 100 results per page. The core REST limit is 5,000 requests per hour. Search allows up to 30 requests per minute for authenticated users and returns at most 1,000 results per search. Here is the budget for a repo with 3,000 PRs in the window:

| Route | Calls | Limit | Wall time |
|---|---|---|---|
| List PRs, 100 per page | 30 | 5,000/h | Under 1 min |
| Reviews per PR | 3,000 | 5,000/h | About 36 min |
| Inline comments per PR | 3,000 | 5,000/h | About 36 min |
| Search, 12 monthly slices of about 250 PRs | 36 | 30/min | About 1.2 min |

That is about 6,030 core calls, or 1.2 hours on one personal access token. Across 3 to 8 repos, plan to run repos in sequence or spread them across the day. A third-party guide claims GraphQL is cheaper per pull request, but I have not seen that confirmed in GitHub's documentation, so the budget above assumes REST.

**Review extraction commands for one repo**

```
# 1. List PRs, newest first; stop paginating once created_at passes the window start
gh api "repos/OWNER/REPO/pulls?state=all&per_page=100&sort=created&direction=desc" --paginate

# 2. Every review submission on one PR, in submission order
gh api "repos/OWNER/REPO/pulls/NUMBER/reviews?per_page=100" --paginate

# 3. Inline review comments on one PR, for judging substance
gh api "repos/OWNER/REPO/pulls/NUMBER/comments?per_page=100" --paginate

# 4. Spot check one reviewer for one month (total must stay under 1,000)
gh search prs --repo OWNER/REPO --reviewed-by LOGIN --created YYYY-MM-01..YYYY-MM-31

# 5. Same spot check in the GitHub search box
repo:OWNER/REPO is:pr reviewed-by:LOGIN created:YYYY-MM-01..YYYY-MM-31
```

*Replace OWNER, REPO, NUMBER, LOGIN and the dates; run step 2 and 3 for every PR in the window.*

Notes on the search side:

- The documented review qualifiers are `reviewed-by:`, `review-requested:`, `review:approved`, `review:changes_requested`, `review:required` and `review:none`. A `review-involves:` qualifier does not appear in GitHub's documentation, so don't rely on it.
- `reviewed-by:` is the right one for sourcing. Unlike `review-requested:`, PRs stay in its results after the person has reviewed them.
- Slice by month and confirm each slice returns a total under 1,000. Above that, results may be silently truncated.

### Keeping the right review state

The reviews endpoint returns every submission in order, so a reviewer who requested changes and later approved appears twice. For approval weight, dedupe by user ID and keep the last entry per PR. For change requests, count from the full history. If you only keep the latest state, you throw away the most valuable event in the file: the change request that came before the approval.

### Removing bots and agents

#### The de-bot pass

1. **Suffix** - Drop logins ending in [bot]
2. **Account type** - Drop accounts whose type is Bot
3. **Named agents** - Drop the bare Copilot login and the 12 agents in the ESEM study
4. **Behaviour** - Flag logins with 0% approvals and over 90% COMMENTED
5. **Human read** - Check flagged accounts for templated comments repeated across PRs

*Each pass catches what the one before it misses, and the last pass is a human read because some agents leave no signature at all.*

The ESEM study "AI-to-AI Code Reviews of GitHub Pull Requests" attributes reviews to 12 agents, including CodeRabbit, Copilot, Gemini Code Assist, Codex, Devin and Claude Code. Use its list as your named-agent pass and check its current version before each run. The same paper warns that the absence of an attributed reviewer signature is not evidence that no AI reviewed the PR. That is why the behavioural pass exists.

> **Watch out:** A suffix-only filter misses about a third of AI review
>
> Copilot posts reviews as the bare login "Copilot", with no [bot] suffix. A standard suffix check silently files about a third of AI review activity as human, and those accounts then score well on comment volume.

Copilot is the only agent the evidence shows posting without a suffix, but no public list exists of other agent logins without one. The behavioural flag is your defence against the ones nobody has catalogued yet.

## How do you resolve employers and stop one vendor filling the slate?

Resolve each person's current employer from at least two independent public traces, then enforce a per-employer cap that you wrote down before seeing the names. Repos that matter to a stack are often dominated by one or two companies, and declared affiliations are unreliable.

### The evidence for current employer

Use these, in this order of strength:

1. **Commit email domain** on recent commits in the window. It is the hardest to leave stale by accident.
2. **Org membership** on GitHub, where it is public.
3. **Profile company field** on GitHub and public professional profiles.

Require two to agree. When they conflict, the most recent dated trace wins, and the row gets flagged. This is not paranoia. In an early analysis of Kubernetes, RedMonk found that committers misattributed to other affiliations, who actually worked for Google or Red Hat, accounted for over 4% of commits.

At 4 to 6 hours, this is the most expensive step in the procedure. Most of that time goes into stitching a GitHub login to a person across sources. [Refolk](/) does that join across GitHub, LinkedIn, and the open web from one plain-English question and returns a current employer to check against the commit email domain.

Ask me this: `Senior Go engineers in Germany who have approved pull requests in etcd or containerd in the last 12 months, excluding Google and Red Hat employees` - [run the search](https://www.refolk.ai/start?q=Senior%20Go%20engineers%20in%20Germany%20who%20have%20approved%20pull%20requests%20in%20etcd%20or%20containerd%20in%20the%20last%2012%20months%2C%20excluding%20Google%20and%20Red%20Hat%20employees).

*Returns named engineers with their GitHub activity and current employer, with the two dominant contributing companies already removed.*

### Why the cap is not optional

Contribution share in the repos that matter can be very lopsided, and it doesn't only fall over time:

- In Kubernetes, Google and Red Hat accounted for 83% of contributions before the project joined CNCF. In the later project journey report they still accounted for 46%, up from a 35% low in between.
- In etcd, the project journey report showed CoreOS leading with 36% of contributions and Google second with 14%.

CNCF DevStats counts reviews as contributions. No one has published a reviewer-only share by employer. If you assume your reviewer pool is as concentrated as these contribution figures, a slate drawn from one repo could be roughly half one vendor. That would make it a list of one company's team, not a market map.

There is no published standard for the cap or for handling off-limits clients, so write both into the brief: a numeric maximum per employer and the list of employers you cannot approach. Apply the strike on declared affiliation in step 6, then re-check the cap after resolution in step 7, since some people will move employer once you look properly.

## How reviewer-first sourcing goes wrong

Most failures come from trusting a label, such as a login suffix, a search qualifier, an owner listing, or a profile company, instead of checking the event underneath it. Each failure below has a pattern that gives it away and a check you can run.

1. **Suffix-only bot filtering.** It shows up as a top-ranked "reviewer" with thousands of comments and no approvals. Check: list every login whose reviews are 0% APPROVED and more than 90% COMMENTED, and read them.
2. **Humans running agents under their own login.** Nothing in the data marks it, because agent-written text posted by a person carries no signature. Check: look for comment bodies with the same structure repeated across unrelated PRs, and don't cite those threads.
3. **Reading `review:changes_requested` as a reviewer-level fact.** That qualifier describes the PR's state. Combining it with `reviewed-by:X` shows X reviewed a PR that had changes requested, not that X requested them. Check: confirm the state per reviewer in the reviews endpoint.
4. **Counting approvals that carry no weight.** An approval from a read-only collaborator or an outside contributor is ignored by branch protection. Check: confirm the person is in CODEOWNERS or OWNERS, or has merged-by records in the repo.
5. **Treating every listed code owner as an active approver.** An approval from any one of the code owners satisfies the rule, so some listed owners never review at all. Check: count approvals actually submitted in the window, not owner listings.
6. **Scoring rubber-stamp approvals on agent PRs.** Rulesets require an extra human approval on unattributed Copilot PRs by default, so people who sit in the approval seat for agent output pile up approvals fast. In one study of 33,596 agent-authored PRs, only 15.9% showed any human participation, so the human approvals that do exist on agent PRs come from a narrow set of people. Check: split approvals by PR author type and rank on human-authored PRs only.
7. **Silently truncated search results.** Any search over 1,000 results may drop the rest without warning. Check: confirm each monthly slice's total count is under 1,000, and slice further if not.
8. **Deduping away the change request.** Keeping only the latest state per user turns "requested changes, then approved" into a plain approval. Check: compute change requests from the full submission history before deduping.
9. **Misattributed employers.** A stale profile field puts someone at their last employer, or hides that they work for an off-limits client. Check: compare commit email domain against the current profile, and flag every disagreement.
10. **Over-reading index samples.** The metro and employer splits above come from 25-profile samples. Check: size the pool from totals only, and verify any employer pattern against the resolved slate itself.

> Anyone can generate a commit. Being the approval a human change needed to merge still takes a person.

## What does the finished slate look like, and what comes next?

The deliverable is 15 to 30 ranked rows. Every row has the person's current employer with its evidence, the three sub-scores, a level read, and one link to a review that person submitted. A hiring manager should be able to open any cited thread and see in under a minute why the person is on the list.

**Slate row**

```
Rank:
Name / GitHub login:
Current employer: NAME (evidence: commit email domain | org membership | profile)
Repos reviewed in window:
Substantive change requests on human-authored PRs (score 0-3):
Distinct authors reviewed (score 0-3):
Merge-weight approvals on human-authored PRs (score 0-3):
Reviews per month (reference: Low 3.38 or fewer, High 6.41 or more):
Owner status: CODEOWNERS/OWNERS path, or merged-by evidence
Level read: Senior | Staff | Unclear, plus one sentence why
Cited thread: PR URL with review anchor, plus one line on what the review caught
Flags: off-limits | over cap | possible agent-drafted comments | employer conflict
```

*One block per person; the cited link must open on a review this person submitted, not just a PR they appear on.*

### Choosing the cited thread

Pick the review that shows judgment a hiring manager would recognise: a change request that caught a correctness or design problem, explained it, and was followed by a fix. Skip threads where the comment looks templated. Skip threads on agent-authored PRs unless the review is the only substantive one the person has. The thread is the evidence for the level read, so if you can't find one, the person drops off the slate.

### Outreach, with honest expectations

Citing the thread in your first message is a reasonable choice, but don't promise anyone that it lifts replies. The evidence is thin. One vendor blog gives an engineer InMail baseline of 4.77%. Another claims outreach that references a GitHub contribution gets 15 to 25% response rates, with no methodology. There is no controlled evidence on citing a specific review thread. Track your own reply rate on review-citing messages against your normal sends, and let your own numbers decide.

### Keeping the method current

Several facts this method relies on are product behaviour that can change: whether Copilot can approve, whether its reviews count toward required approvals, the ruleset default for agent PRs, and which agents post without a suffix. Before each new slate, re-read GitHub's ruleset and code-owner documentation, re-check the current version of the ESEM agent list, and re-run the behavioural flag rather than reusing an old exclusion list. Re-pull the same repos over a fresh window when a seat reopens. Reviewer pools shift as people change employer, and step 7 is where a stale slate goes wrong.

> **Note:** What this method does not tell you
>
> It ranks judgment that is visible in public review on the repos you chose. It says nothing about engineers whose best work is in private code, so pair it with other sourcing channels when the stack is mostly closed-source.

#### Before you hand over the slate

- [ ] Every target repo has a one-line reason and a parsed CODEOWNERS or OWNERS file, or is marked as using merged-by evidence instead
- [ ] Every monthly search slice returned a total under 1,000
- [ ] Change requests were counted from full submission history before deduping by user
- [ ] The bare Copilot login, all [bot] and type Bot accounts, and the ESEM-listed agents are removed
- [ ] Every login with 0% approvals and over 90% comments was read by a person
- [ ] Approval scores count human-authored PRs only, from people with confirmed write access
- [ ] Every row has a current employer backed by two agreeing traces, or carries an employer-conflict flag
- [ ] No employer exceeds the cap written in the brief, and no off-limits employer appears
- [ ] Every row links to a review the person submitted, and no cited thread looks templated
- [ ] The slate has between 15 and 30 names, ranked, with sub-scores visible

## Frequently asked questions

### Can I just use reviewed-by: search on GitHub to find senior reviewers?

No, use it for spot checks and slicing, not scoring. The reviewed-by: qualifier keeps a pull request in results after the person reviews it, which makes it useful for confirming activity, but search caps each query at 1,000 results and qualifiers like review:changes_requested describe the PR, not the individual reviewer. Score from the per-PR reviews endpoint, where every submission carries the reviewer's login and state.

### How do I filter AI bots from GitHub contributors when they don't have a [bot] suffix?

Run several passes, not one. Drop logins ending in [bot] and accounts of type Bot, then the bare Copilot login, then the 12 agents named in the ESEM AI-to-AI review study, including CodeRabbit, Gemini Code Assist, Codex, Devin and Claude Code. Finally, flag behaviour: any login with zero approvals and more than 90% plain comments, or templated comment bodies repeated across PRs, gets a human read.

### Does high review volume mean someone is a staff engineer?

Not on its own, and no published study has validated review metrics against job level. One Cassandra study banded reviewers at 3.38 or fewer reviews a month as low experience and 6.41 or more as high, which works as a sanity reference. Volume shows engagement. Level comes from reading what the person caught in a cited thread, and that call is yours to make.

### Does citing a specific code review in outreach improve reply rates?

There is no controlled evidence either way. Vendor blogs cite an engineer InMail baseline of 4.77% and claim 15 to 25% replies when outreach references a GitHub contribution, but the second figure comes with no methodology. Cite the thread because it shows you did the work, then measure your own reply rate against your normal sends before you claim it helps.

### What if a target repo has no CODEOWNERS or OWNERS file?

Swap it out if you can, because without an owner file you lose the cheapest public proof that an approval carries merge weight. If the repo is essential to the role, use merged-by records instead: a person who has merged PRs has write access, so their approvals counted. Mark those approval scores as inferred in the slate.

---

*From the Refolk guide library. I revise these guides rather than replacing them, so the current version is always at https://www.refolk.ai/guides/reviewer-first-senior-engineer-slate*
