SabryFarrag/review-pointers-beyond-the-change

Review Pointers Beyond the Change

DOI: to be added at deposit

This dataset holds the data of the study Reviewing Beyond the Change: Repository Size and Existing Code Across Agent and Human Pull Requests (Sabry E. Farrag). The study measures whether top-level inline review comments on GitHub pull requests name an existing repository item outside the change under review, how often they do so as repositories grow, and whether comments on coding-agent pull requests differ from comments on human pull requests in the same repositories.

The paper asks four questions. RQ1: how often do comments on agent pull requests name an existing item outside the change? RQ2: does that share rise with repository size? RQ3: does the size gradient differ between agent and human pull requests in the same repositories? RQ4 (exploratory): does it differ when the agent's context file is present?

Summary

• 483,889 top-level inline review comments from 3,029 GitHub repositories, on pull requests created from 2024-12-01 up to 2026-10-01: 110,661 on pull requests authored by six coding agents (Copilot, Claude Code, OpenAI Codex, Devin, Cursor, Google Jules) and 373,228 on pull requests without agent marks.
• For each comment, the measured outcome (does it name an existing item outside the change?), the items it names, chance matches against size-matched repositories, and the variables of the study's models.
• A stratified validation sample of 600 comments with inclusion probabilities, the answers of three language models (two judges and an adjudicator) and of human readers, and the reference labels.
• One row per repository of the frame (4,138) with size, language, stars, age and human authors.

Files

Each file is one configuration with a single train split. All files are Parquet with zstd compression.

File	Configuration	Rows	Columns	Size on disk
data/review_comments/*.parquet (six parts)	review_comments	483,889	20	47.8 MB
data/analysis_table.parquet	analysis_table	483,889	42	6.9 MB
data/measured_links.parquet	measured_links	483,889	14	5.0 MB
data/negative_controls.parquet	negative_controls	483,889	10	2.8 MB
data/validation_sample.parquet	validation_sample	600	19	0.1 MB
data/repositories.parquet	repositories	4,138	17	0.2 MB
total				62.7 MB

Every per-comment file has one row per comment_id and the same 483,889 comments; join them on comment_id. validation_sample is a subset of them; repositories joins on repository.

How the data were built

1. Frame. 4,138 GitHub repositories with at least 100 stars from the agent arm of the AIDev dataset (Li et al., 2025) as first released; 4,088 could be listed. For each, every pull request created in the window was listed through the GitHub API.
2. Arms. A pull request is in the agent arm when AIDev labels it with an agent, or, without a label, when its author is an agent's bot account, its head branch starts with an agent's prefix, or its description carries an agent's signature. It is in the human arm when its author is a user account and its description, head branch and title carry no agent or AI-tool marker. Every agent pull request with a review thread was kept, and up to 100 human pull requests with a review thread per repository were drawn at random (seed 20261007).
3. Comments. The unit is the first comment of a review thread on a line of code, written by a user account (not a [bot]) other than the pull request's author. Comments addressed to an agent (@copilot, @claude, ...) are kept and marked. Comments the instrument could not measure (60), duplicates (5) and comments whose repository had zero or unknown size at the base commit (2,424) were excluded.
4. Measurement. A deterministic instrument reads the names written in a comment (links to files of the repository, paths, file names, module names, and symbols written as code or as calls) and looks each one up in the repository's tree at the pull request's base commit. The outcome is 1 when at least one name resolves, unambiguously, to an existing item that is not among the files the pull request had changed when the comment was written. No person or model labels the comments in the main analysis.
5. Negative controls. The same names are resolved against other repositories of similar size (the next repository in size, the same re-paired on code files, and five random partners in a size band), where a match can only be chance.
6. Validation. 600 comments in 12 strata (arm by size third by verdict) were checked: facts against the GitHub API, judgements by gemma4:12b and Claude Sonnet 5.5 with qwen3:14b adjudicating, and a check by human readers, whose labels take precedence where they answered.

Schema

review_comments (data/review_comments/*.parquet (six parts), 483,889 rows)

The review comments of the analysis, one row per comment: every top-level inline review comment on a selected pull request that a user account other than the pull request's author wrote, measured by the instrument and kept in the analysis (Section 3.1 of the paper). Each row keeps the identifiers that retrieve the comment from GitHub: https://github.com/{repository}/pull/{pr_number}#discussion_r{comment_id}, or the REST endpoint GET /repos/{repository}/pulls/comments/{comment_id}.

One row per comment_id.

Column	Type	Meaning
comment_id	int64	GitHub's identifier of the pull-request review comment.
repository	string	The repository, as owner/name.
pr_number	int64	The pull request's number in its repository.
arm	string	agent (a pull request with an agent's marks) or human (one without agent or AI-tool marks), by the rules of Section 3.2.
agent_group	string	The agent that authored the pull request (Copilot, Claude_Code, OpenAI_Codex, Devin, Cursor, Google_Jules), or human for the human arm.
comment_author	string	The comment's author, pseudonymised (u_ followed by 16 hex digits; the same account has the same code in every file).
comment_author_association	string	GitHub's author association of the comment's author with the repository (OWNER, MEMBER, COLLABORATOR, CONTRIBUTOR, NONE).
comment_created_at	timestamp (UTC)	When the comment was created.
pr_created_at	timestamp (UTC)	When the pull request was created.
pr_author_association	string	GitHub's author association of the pull request's author.
pr_additions	int32	Lines the pull request adds (null for 32 comments whose pull request returned no size).
pr_deletions	int32	Lines the pull request deletes (null as above).
pr_changed_files	int32	Files the pull request changes (null as above).
base_commit	string	The pull request's base commit (SHA), the tree against which names are resolved.
comment_commit	string	The commit the comment was written on (SHA); null for 853 comments that do not carry one.
file_path	string	The file the comment is attached to.
addressed_to_agent	int8	1 when the text matches @(copilot|codex|claude|devin|cursor|jules), ignoring case: an instruction to an agent rather than review. Excluded from the primary analyses.
pr_people	list	For a pull request opened by an agent's bot account, the accounts linked to it (assignees, users whose review was requested or who requested it, the account of a 'Requested by' line), pseudonymised; null for other pull requests.
pr_people_strict	list	The narrower rule's subset of pr_people (the developer behind the pull request), pseudonymised.
text	string	The comment's text as collected (public GitHub content; see Personal data).

analysis_table (data/analysis_table.parquet, 483,889 rows)

The model variables of the analysis, one row per comment, joined to review_comments by comment_id. The last column below gives each variable's name in the paper and its scripts. The RQ1 and RQ2 population is is_agent == 1 and addressed_to_agent == 0; the RQ3 comparison set is in_rq3 == 1; RQ4 is the RQ1 population without agent_group == "Devin". Sizes enter the models as log10_code_files centred.

One row per comment_id.

Column	Type	Meaning	Name in the paper
comment_id	int64	GitHub's identifier of the review comment.
repository	string	The repository (the clustering unit and the fixed effect).	unit
pr_number	int64	The pull request's number.	pr
is_agent	int8	1 for the agent arm, 0 for the human arm.	is_agent
agent_group	string	The agent, or human.	agent_group
outside_ref	int8	The outcome: 1 when the comment names an existing repository item outside the change (Section 3.4).	ref_out
any_item_ref	int8	1 when the comment names any resolvable repository item, the change ignored.	any_ref
n_candidates	int16	Candidate names the instrument read in the comment.	n_cands
next_partner_match	int8	Negative control, next partner: 1 when the comment's candidates resolve in the next repository in size of another owner.	placebo_ref
next_partner_cf_match	int8	Negative control, next partner re-paired on code files.	placebo_ref_cf
band_match_mean	double	Negative control, random band: the mean match over the partners drawn (null when no partner was found).	placebo_band
band_width	double	The size band the random partners were drawn from, as a share of size (0.15, 0.3, 0.5, 1.0).	band_matched
code_files_at_base	int32	Repository size: files with a code extension in the full tree at the base commit.	size_at_base
log10_code_files	double	log10(code_files_at_base), not centred.	lsize
reviewer_insider	int8	1 when the comment's author is OWNER, MEMBER or COLLABORATOR.	reviewer_insider
author_insider	int8	1 when the pull request's author is OWNER, MEMBER or COLLABORATOR.	author_insider
addressed_to_agent	int8	1 when the comment addresses an agent (see review_comments).	addressed
pr_log_lines	double	log10(additions + deletions + 1) of the pull request.	pr_lines
pr_log_tree_share	double	log10((changed files + 1) / code_files_at_base): the pull request's share of the tree.	pr_cover
pr_month	string	Month of the pull request's creation (YYYY-MM).	month
post_nov_2025	int8	1 for pull requests created from 2025-11-01.	post_window
comment_commit_fallback	int8	1 when the comment's commit could not be fetched and the pull request's head was read instead.	fallback
bot_like_reviewer	int8	1 when the comment's author has a bot-like login without the [bot] suffix.	bot_reviewer
ai_review_format	int8	1 when the comment is formatted as AI review-tool output.	ai_format
delegator	int8	1 when the comment's author is among the people linked to a bot-opened agent pull request (broad rule).	delegator
delegator_strict	int8	The same under the narrower rule.	delegator_strict
human_arm_insider_author	int8	1 for a human-arm pull request whose author is an insider.	hum_in
stars	int32	The repository's stars at collection.	stars
log10_stars	double	log10(stars + 1).	lstars
repo_age_years	double	The repository's age in years when the pull request was created.	repo_age
human_authors_in_window	int32	Distinct human pull-request authors of the repository in the window.	authors_window
log10_human_authors	double	log10(human_authors_in_window + 1).	lauthors
language	string	The repository's primary language (null when GitHub gives none).	language
log10_reviewers	double	log10 of the distinct comment authors of the repository in the table.	lreviewers
log10_pr_comments	double	log10 of the comments of the pull request in the table.	lpr_comments
context_file	int8	Agent arm: 1 when the context file the pull request's own agent reads exists at the base commit (Section 3.4); null for the human arm and Devin.	context_file
context_file_v2	int8	context_file, also counting AGENTS.md for Copilot pull requests from 2025-08-28.	context_file_v2
agents_md	int8	Copilot pull requests: 1 when AGENTS.md exists at the base commit; null otherwise.	agents_md
codeowners	int8	1 when a CODEOWNERS file exists at the base commit.	codeowners
in_rq3	int8	1 for the RQ3 comparison set (comments not addressed to an agent, repositories with both arms, human comments capped at 300 per repository by seed 20261007).	in_rq3
in_rq3_all	int8	The comparison set with addressed comments restored (sensitivity).	in_rq3_all
rq3_fe_kept	int8	1 when the comment's repository varies in the outcome within the comparison set (kept by a fixed-effects logit).	fe_kept

measured_links (data/measured_links.parquet, 483,889 rows)

The instrument's measurement of each comment (Section 3.4): the candidates it read, the names it resolved as items outside the change, and how the change was read. Each element of hits is a struct with kind (url, path, module or symbol), text (the name as written), target (the item it resolved to at the base commit) and process (true for a process file such as CHANGELOG, CODEOWNERS, a workflow or a Makefile).

One row per comment_id.

Column	Type	Meaning
comment_id	int64	GitHub's identifier of the review comment.
repository	string	The repository.
status	string	The measurement's status; every comment in this release has status ok (60 others were excluded).
n_candidates	int16	Candidate names read in the comment (outside fenced code, not in the commented hunk).
n_outside_refs	int16	Candidates that resolved to an item outside the change.
outside_ref	int8	The outcome: 1 when n_outside_refs > 0.
hits	list<struct<kind: string, text: string, target: string, process: bool>>	The resolved names outside the change (struct: kind, text, target, process).
change_read_at	string	Where the change was read: at (the comment's commit) or pr_head (fallback to the pull request's head).
change_files	int32	Files in the change: differing from the base commit and changed by the pull request itself.
diff_files	int32	Files differing between the base commit and the comment's commit.
own_file_list	bool	True when GitHub returned the pull request's full file list (else the change is the difference alone).
any_item_ref	int8	The same instrument with the change ignored: 1 when any candidate resolves to an existing item.
any_item_n_refs	int16	Candidates resolving to any existing item.
any_item_hits	list<struct<kind: string, text: string, target: string, process: bool>>	Those names (struct as in hits).

negative_controls (data/negative_controls.parquet, 483,889 rows)

The negative controls (Section 3.5): each comment's candidates resolved, with the same rules, against other repositories of similar size, where a match cannot be a reference to the reviewed project. Partners are read at their indexed default-branch head and nothing in them counts as changed.

One row per comment_id.

Column	Type	Meaning
comment_id	int64	GitHub's identifier of the review comment.
repository	string	The repository.
next_partner	string	Next partner (as pre-specified): the next repository in size order, counted by all paths at the indexed head, among repositories of another owner.
next_partner_match	int8	1 when a candidate resolves in the next partner.
next_partner_cf	string	The next partner re-paired on code files.
next_partner_cf_match	int8	1 when a candidate resolves in the re-paired partner.
band_partners	list	Random band: up to five partners drawn (seed 20261009) among repositories of another owner with the same primary language within the size band.
band_matches	list	1 or 0 for each band partner, in the order of band_partners.
band_match_mean	double	The mean of band_matches (null when no partner was found).
band_width	double	The band used: the narrowest of 0.15, 0.3, 0.5 and 1.0 of size that offered five partners (else the widest that offered any).

validation_sample (data/validation_sample.parquet, 600 rows)

The validation sample (Section 3.8, Appendix C): 600 comments in 12 strata, arm by repository-size third by the instrument's verdict at sampling, with each comment's inclusion probability, the facts checked against the GitHub API, every judge's answers and the reference label. Judge answers are lists of structs, one per judged item: item is the matched item's index (matching items[].k) for a flagged comment and u for the question asked of an unflagged comment; refers and directs answer whether the comment refers to the item and directs the contributor to it; names_item whether an unflagged comment names a repository item outside the commented hunk, with names the names given; answers are yes, no or na. People's answers carry sheet (1 or 2; sheet 2 takes precedence where both answered) and n_readers; readers are not identified.

One row per comment_id.

Column	Type	Meaning
comment_id	int64	GitHub's identifier of the review comment (in review_comments).
repository	string	The repository (the bootstrap's cluster).
arm	string	agent or human.
size_third	int8	The repository-size third of the comment within its arm (1 smallest, 3 largest).
flagged_at_sampling	int8	The instrument's verdict when the sample was drawn (the stratum's third element).
stratum	string	arm|size_third|flagged_at_sampling.
carried_over	bool	True for a comment carried over with certainty from the earlier round's precision check.
stratum_population	int32	Comments in the stratum.
stratum_quota	int16	The stratum's quota.
inclusion_probability	double	1 for a carried-over comment; otherwise the stratum's remaining quota over its remaining comments.
weight	double	1 / inclusion_probability, the weight of every validation estimate.
flagged_now	int8	The instrument's verdict as it now stands (outside_ref); the validation scores this verdict.
items	list<struct<k: int64, kind: string, text: string, target: string, process: bool, exists_at_base: bool, symbol_in_file: bool, outside_change: bool>>	For a flagged comment, up to three matched items with the facts checked against the GitHub API (struct: k, kind, text, target, process, exists_at_base, symbol_in_file, outside_change; a null fact is one GitHub did not answer).
reference_label	int8	The reference label: 1 when the comment truly names an item outside its change (flagged and correct, or unflagged and a confirmed miss).
reference_source	string	human when people's answers decided the label, model when the model judges did.
judge_gemma	list<struct<item: string, refers: string, directs: string, names_item: string, names: list, reason: string>>	Answers of gemma4:12b (Google, run locally, temperature 0, JSON-constrained), the first judge.
judge_sonnet	list<struct<item: string, refers: string, directs: string, names_item: string, names: list, reason: string>>	Answers of Claude Sonnet 5.5 (Anthropic), the second judge; its reason field is a fixed note.
adjudicator_qwen	list<struct<item: string, refers: string, directs: string, names_item: string, names: list, reason: string>>	Answers of qwen3:14b (Alibaba, run locally, temperature 0, JSON-constrained), which decides where the two judges disagree.
reader_answers	list<struct<sheet: int64, item: string, refers: string, directs: string, names_item: string, names: list, n_readers: int64>>	People's answers on the review sheets (null where no person answered); they take precedence over the models.

repositories (data/repositories.parquet, 4,138 rows)

One row per repository of the frame (the list of repositories the study started from), with its traits and its comments in this release.

One row per repository.

Column	Type	Meaning
repository	string	The repository, as owner/name.
available	bool	True when the repository's pull requests could be listed at collection (4,088); false for the 50 that could not.
language	string	Primary language as GitHub reports it (null when none).
stars	int32	Stars at collection.
created_at	timestamp (UTC)	When the repository was created.
age_years_at_window_end	double	Age in years at the end of the collection window (2026-10-01).
human_pr_authors_in_window	int32	Distinct human pull-request authors in the window.
prs_in_window_search	int32	Pull requests created in the window by GitHub's search count (the completeness check).
prs_in_window_listed	int32	Pull requests created in the window that the collection listed.
pairing_code_files	int32	Code files at the indexed head, the size by which the re-paired control pairs repositories (null when not indexed).
comments	int32	Comments of the repository in review_comments.
agent_comments	int32	Of which on agent pull requests.
rq1_comments	int32	Agent-arm comments not addressed to an agent (the RQ1 and RQ2 population).
rq3_comments	int32	Comments in the RQ3 comparison set.
prs_with_comments	int32	Pull requests with at least one comment in review_comments.
code_files_at_base_median	double	Median repository size (code files at the base commit) over the repository's comments; null without comments.
code_files_at_base_max	int32	Largest size at a base commit over the repository's comments.

Loading

from datasets import load_dataset

review_comments = load_dataset("SabryFarrag/review-pointers-beyond-the-change", "review_comments", split="train")
analysis_table = load_dataset("SabryFarrag/review-pointers-beyond-the-change", "analysis_table", split="train")
measured_links = load_dataset("SabryFarrag/review-pointers-beyond-the-change", "measured_links", split="train")
negative_controls = load_dataset("SabryFarrag/review-pointers-beyond-the-change", "negative_controls", split="train")
validation_sample = load_dataset("SabryFarrag/review-pointers-beyond-the-change", "validation_sample", split="train")
repositories = load_dataset("SabryFarrag/review-pointers-beyond-the-change", "repositories", split="train")

# or straight into pandas
import pandas as pd
comments = pd.read_parquet("hf://datasets/SabryFarrag/review-pointers-beyond-the-change/data/review_comments/ (six parquet parts)")

The population of RQ1 and RQ2, with the comments' text:

from datasets import load_dataset

frame = load_dataset("SabryFarrag/review-pointers-beyond-the-change", "analysis_table", split="train").to_pandas()
texts = load_dataset("SabryFarrag/review-pointers-beyond-the-change", "review_comments", split="train").to_pandas()
rq2 = frame.query("is_agent == 1 and addressed_to_agent == 0").merge(texts[["comment_id", "text"]], on="comment_id")
print(len(rq2), rq2["outside_ref"].mean())

A comment's diff hunk and thread are not included; each can be retrieved from GitHub with GET /repos/{repository}/pulls/comments/{comment_id}.

Intended uses

• Re-analysing how review comments point to existing code, by repository size, arm, agent and repository traits.
• Studying review of coding-agent pull requests against human pull requests in the same repositories.
• Benchmarking or improving methods that link developer text to code elements, using the validation sample's reference labels and judge answers.

The data are not intended for profiling individual developers; see Personal data.

Limitations

• The instrument misses many references. In the validation sample its weighted precision is 79.7 per cent and its recall 43.6 per cent (59.3 per cent in the agent arm, 38.8 per cent in the human arm), so measured shares understate how often comments point to existing code. The sample holds few misses and cannot estimate reliably how recall changes with repository size.
• The reference labels rest partly on models. Where no person answered, reference_label is the model judges' verdict (reference_source == "model"), and agreement with it is agreement with the models.
• The known-groups validity check failed. Insiders were expected to name items outside the change more often than other reviewers; the odds ratio was 0.89 (0.68 to 1.17) in the agent arm and 1.00 (0.90 to 1.12) in the human arm.
• Associations, not causes. Repository size goes with many other traits (age, stars, contributors, language, review practice). The estimates describe how outside references vary with size and arm; they do not show that size or authorship causes them.
• Scope. Repositories with at least 100 stars drawn from AIDev's agent arm; one comment per review thread (the first); the window ends on 2026-10-01. Human-arm pull requests are those without agent marks, which may include undisclosed AI assistance.
• Chance matches. Larger trees offer more names to match by chance; use the negative-control columns to net them out.

Personal data

The comments are public GitHub content. GitHub logins of comment authors and of the people linked to agent pull requests are replaced by keyed pseudonyms (HMAC-SHA256 of the lower-cased login under a secret salt that is not published), so the same account has the same code in every file, and nobody without the salt can test a login against a code. Comment texts are kept as collected and may contain @-mentions and other names written by their authors. Repository names, pull-request numbers and comment identifiers are kept so that every comment can be retrieved from its public source; a comment deleted on GitHub stays here as collected. The human readers who checked labels are not identified; their answers carry only the sheet and the number of readers. To request removal of a comment, open a discussion on this repository with its comment_id.

License

Proposed, for the author to confirm: the tables, measurements, controls, validation labels and judge answers are released under CC BY 4.0. The texts of the review comments are the content of their GitHub authors, reproduced from public repositories under GitHub's Terms of Service; the CC BY 4.0 license does not extend to them, and their reuse is subject to their authors' rights and GitHub's terms.

Source

Collected through the GitHub REST and GraphQL APIs (2026-10). The repository frame was drawn from the AIDev dataset (Li et al., 2025). The study's replication deposit (Zenodo, DOI to be added at deposit) holds the files the analysis read, including the diff hunks, and scripts that recompute the reported estimates.

Citation

@misc{farrag_reviewing_beyond_the_change,
  author       = {Farrag, Sabry E.},
  title        = {Reviewing Beyond the Change: Repository Size and Existing Code Across Agent and Human Pull Requests},
  year         = {2026},
  note         = {Dataset; DOI to be added at deposit},
  howpublished = {Hugging Face dataset SabryFarrag/review-pointers-beyond-the-change}
}

Sabry E. Farrag, ORCID 0009-0002-0735-7443, School of Architecture, Computing and Engineering, University of East London.

Acknowledgements

We are grateful to Amelie Rosso, Aziza Tawfiq Yousif, Barry Fishel, Emilian Patrascu, Ivan Perslav, Merna Ezz Eldien, Wael Osama, Wei Fan and Youssef Saber, senior software engineers who gave this study their time and expertise. The study is better for their help.