How does Atlas handle R package dependencies during a PR review?

Atlas reads the `renv.lock` file to understand the R package's dependencies. It ensures that proposed changes do not introduce conflicts or break the existing dependency structure, which is crucial for maintaining a reproducible R environment.

Can Atlas automatically fix R formatting issues with `Air`?

Yes, Atlas can format changed R files using `Air`, the R formatter. This action is permission-gated, meaning Atlas will present the proposed formatting changes as a unified diff for your approval before writing them to files like `R/my_script.R`.

How does Atlas ensure my R code changes don't break other parts of the package?

Atlas uses its `lsp` tool's `findReferences` operation for every changed R function signature. This checks for any callers across your R package that might be broken by the modification, even if those callers are not directly visible in the pull request diff.

What R testing frameworks does Atlas support for PR reviews?

Atlas directly supports the `testthat` framework, which is standard for R packages. It executes `devtools::test()` via its `bash` tool, running all `testthat` blocks in your `tests/testthat/` directory and reporting results as a `todowrite` list.

Is Atlas safe to use with my R codebase? Will it make changes without my permission?

Atlas is designed with safety in mind. Every tool call is permission-gated, and it drafts a plan in a read-only agent before executing. All proposed file edits, such as changes to `R/` files or `DESCRIPTION`, are presented as unified diffs for your explicit approval before Atlas writes them.

How does Atlas provide more context than a standard `git diff` for R files?

Atlas uses its `read` tool to pull the *full* content of changed R files, not just the diff hunks. This allows it to analyze the surrounding code and understand the broader implications of changes, which is essential for catching bugs that a line-by-line diff might miss in complex R scripts.

Can Atlas help me update `roxygen2` documentation or `NAMESPACE` during an R review?

Yes, Atlas can regenerate the `NAMESPACE` file using `roxygen2` if necessary, especially after changes to exported functions or their `roxygen2` docblocks. This action, like all others, is subject to your permission and approval via a unified diff.

Review a Pull Request in R with Atlas in 2026

In 2026, R developers review pull requests with Atlas by fetching the branch, reading changed files in full, checking function signature references with the LSP tool, and running `testthat` suites, ensuring comprehensive code quality beyond a simple line-by-line diff.

How does Atlas fetch and prepare an R pull request diff?

Atlas begins reviewing an R pull request by fetching the target branch and generating a unified diff, much like a human developer would in 2026. It uses its internal VCS layer to access `git` data, providing `status`, `diff`, `diffRaw`, and `commits` operations to understand the proposed changes.

When an R developer initiates a pull request review, Atlas first uses its `bash` tool to fetch the relevant branch, mirroring the `git fetch` and `git diff` commands a developer would execute. This initial step produces the raw patch and identifies all changed files within the R package structure, typically found in `R/` directories or affecting the `DESCRIPTION` file. Unlike a standard `git diff` that only shows hunks, Atlas then employs its `read` tool to pull the *full* content of these changed R files. This crucial distinction ensures that Atlas has complete surrounding context, allowing it to analyze code beyond the immediate lines of change, which is vital for understanding how modifications in one R function might impact another, even if they are not adjacent in the diff.

How does Atlas gain full context for R code changes?

To catch subtle bugs in R code, Atlas goes beyond line-by-line diffs by reading entire changed files and leveraging its `lsp` tool. In 2026, this approach helps identify issues where a modified function signature in an R package might break callers not visible in the immediate patch.

Atlas ensures a thorough review of R code by first using its `read` tool to access the complete content of any modified R files, not just the diff hunks. This allows it to understand the broader context of changes, such as how a new argument in an R function defined in `R/my_function.R` might interact with other parts of the package. For every changed function signature, Atlas then utilizes its `lsp` tool's `findReferences` operation. This is critical for R packages, as it can detect if a modification to an exported function's signature, perhaps documented with `roxygen2` docblocks, has inadvertently broken any callers that were not part of the original diff. Furthermore, Atlas employs its `grep` tool to search for specific patterns that *should* have been updated but were missed. This includes checking for old constant names, stale copies of R code, or feature flags that might need adjustment across the codebase, ensuring consistency in files like `R/utils.R` or even within `tests/testthat/` files.

How does Atlas verify R code quality with `testthat` and `Air`?

Atlas rigorously verifies R code quality by integrating directly with the R toolchain, including `testthat` for unit testing and `Air` for formatting. In 2026, Atlas can run `devtools::test()` behind a permission prompt, ensuring that all changes adhere to established R package standards and pass existing test suites.

After analyzing the diff and context, Atlas proceeds to verify the R code's integrity. It uses its `bash` tool to execute the R package's test suite, specifically running `devtools::test()` which in turn invokes `testthat` tests located in `tests/testthat/`. This step is permission-gated, requiring explicit user approval before execution, ensuring safety. Atlas then reports any test failures or warnings as a `todowrite` list, ordered by severity, allowing the R developer to prioritize fixes. Beyond testing, Atlas can also ensure code style consistency. It uses `Air`, the R formatter, to format changed files, and then regenerates the `NAMESPACE` file with `roxygen2` if necessary, maintaining package integrity. Atlas also considers the `renv.lock` file to understand package dependencies, ensuring that any changes do not introduce conflicts or break existing dependency structures, which is crucial for reproducible R environments.

How does Atlas ensure safety and approval during R pull request reviews?

Atlas prioritizes safety and transparency in R pull request reviews through a multi-stage approval process. Every Atlas tool call is permission-gated, and it drafts a plan in a read-only agent before executing any changes, providing R developers with full control over the review workflow in 2026.

Atlas is designed with robust safety mechanisms for R developers. Every tool call, whether it's running `bash` to execute `devtools::test()` or using `Air` for formatting, is permission-gated against `allow`, `ask`, and `deny` rules. This means Atlas will always seek explicit approval before performing actions that modify the R codebase or its environment. Before making any changes, Atlas drafts a comprehensive plan in a read-only plan agent, presenting it to the user for review. Only after explicit approval does it switch to a build agent to execute the plan. Furthermore, for every file edit Atlas proposes, it computes a unified diff and surfaces it for approval before writing. This allows R developers to see precisely what changes Atlas intends to make to files like `R/my_script.R` or `DESCRIPTION`. Atlas also snapshots file changes as `git` patches, enabling easy diffing and rolling back of edits, providing an additional layer of safety and control over the R project's version history.

Step by step

01Fetch the R pull request branch and generate the raw diff using Atlas's `bash` tool, mirroring `git fetch` and `git diff`.
02Read the full content of all changed R files, including `R/` scripts and `DESCRIPTION`, using Atlas's `read` tool to gain complete context beyond diff hunks.
03For every changed R function signature, use Atlas's `lsp` tool with `findReferences` to check for broken callers across the R package, including those not in the immediate diff.
04`grep` for old constant names, stale R code copies, or feature flags that should have been updated but were missed, using Atlas's `grep` tool.
05Run the `testthat` suite by executing `devtools::test()` via Atlas's `bash` tool, behind a permission prompt, and report findings as a `todowrite` list.
06If necessary, have Atlas format the changed R files with `Air` and regenerate `NAMESPACE` using `roxygen2`, presenting a unified diff for approval.
07Review Atlas's proposed changes, including any `git` patches for file edits, and approve them before Atlas stages and creates commits.

Frequently asked questions

How does Atlas handle R package dependencies during a PR review?: Atlas reads the `renv.lock` file to understand the R package's dependencies. It ensures that proposed changes do not introduce conflicts or break the existing dependency structure, which is crucial for maintaining a reproducible R environment.
Can Atlas automatically fix R formatting issues with `Air`?: Yes, Atlas can format changed R files using `Air`, the R formatter. This action is permission-gated, meaning Atlas will present the proposed formatting changes as a unified diff for your approval before writing them to files like `R/my_script.R`.
How does Atlas ensure my R code changes don't break other parts of the package?: Atlas uses its `lsp` tool's `findReferences` operation for every changed R function signature. This checks for any callers across your R package that might be broken by the modification, even if those callers are not directly visible in the pull request diff.
What R testing frameworks does Atlas support for PR reviews?: Atlas directly supports the `testthat` framework, which is standard for R packages. It executes `devtools::test()` via its `bash` tool, running all `testthat` blocks in your `tests/testthat/` directory and reporting results as a `todowrite` list.
Is Atlas safe to use with my R codebase? Will it make changes without my permission?: Atlas is designed with safety in mind. Every tool call is permission-gated, and it drafts a plan in a read-only agent before executing. All proposed file edits, such as changes to `R/` files or `DESCRIPTION`, are presented as unified diffs for your explicit approval before Atlas writes them.
How does Atlas provide more context than a standard `git diff` for R files?: Atlas uses its `read` tool to pull the *full* content of changed R files, not just the diff hunks. This allows it to analyze the surrounding code and understand the broader implications of changes, which is essential for catching bugs that a line-by-line diff might miss in complex R scripts.
Can Atlas help me update `roxygen2` documentation or `NAMESPACE` during an R review?: Yes, Atlas can regenerate the `NAMESPACE` file using `roxygen2` if necessary, especially after changes to exported functions or their `roxygen2` docblocks. This action, like all others, is subject to your permission and approval via a unified diff.

Try Atlas in your terminal

The terminal-native AI coding agent. Free core, single binary.

Install Atlas

Related guides

Review a Pull Request with Atlas (2026 Workflow)

How to review a pull request with Atlas in 2026: bash produces the raw patch, read pulls whole files, the lsp tool's findReferences checks callers the diff never shows.

Atlas for R: A Terminal-Native AI Coding Agent for tidyverse, roxygen2, and testthat in 2026

Atlas is a terminal-native AI coding agent for R in 2026. It reads roxygen2 docblocks and renv.lock, rewrites loops as dplyr or purrr pipelines, and runs devtools::test().

Debug a single failing test in R with Atlas in 2026

In 2026, R developers use Atlas to efficiently debug single failing tests within `testthat` suites. Isolate, analyze, and fix R code with terminal-native AI.

Run the test suite and triage failures in R with Atlas in 2026

Efficiently triage R test failures with Atlas. Turn a wall of red testthat output into a prioritized list of distinct root causes, leveraging renv and Air.

Document a module with a README in R with Atlas in 2026

In 2026, R developers use Atlas to generate accurate, up-to-date README documentation for their R packages. Atlas leverages `lsp`, `read`, and `grep` to describe what R code actually does, not what it was intended to

Rename a symbol across the repo in R with Atlas in 2026

In 2026, R developers use Atlas to safely rename functions, classes, or constants across their codebase. Atlas leverages `lsp`, `grep`, and `edit` to ensure accurate refactoring, integrating with `testthat` and `renv`

Diagnose a hanging or long-running R command with Atlas in 2026

For R developers in 2026, Atlas helps diagnose whether a build or script is genuinely slow or silently blocked on input. Use Atlas to unstick `testthat` suites, `renv` restores, or `Air` formatting, ensuring your R

Plan a Multi-File Change Before Editing in R with Atlas in 2026

In 2026, R developers use Atlas to design and review multi-file changes across DESCRIPTION packages and testthat suites before modifying any code. Ensure your renv dependencies and Air formatting are considered in a

Browse this resource hub