How does Atlas handle F# file order dependencies during a PR review?

Atlas explicitly reads the order from your .fsproj file. This ensures its internal code index, built with AST declarations, respects F#’s crucial compilation order, providing accurate semantic understanding during a pull request review.

Can Atlas run my F# Expecto tests as part of a pull request review?

Yes, Atlas can run your F# Expecto tests. It executes the dotnet test command behind a permission prompt, allowing you to validate functionality and catch regressions introduced by the pull request changes before approval.

How does Atlas ensure F# code formatting is consistent in a PR?

Atlas integrates with fantomas, the F# code formatter. It can automatically run fantomas over all changed .fs files in a pull request, presenting the formatted diff for your approval to ensure consistent styling across the codebase.

What if a F# signature change in a PR breaks code outside the diff?

Atlas addresses this by using the lsp tool's findReferences operation. For every changed F# function or type signature, Atlas proactively checks all callers across your F# solution, even those not directly in the diff, to identify potential breaking changes.

Does Atlas keep my F# code off third-party servers during review?

Yes, Atlas can build its code index using local Ollama embeddings. This capability ensures that your F# source code remains on your local machine, preventing it from being sent to third-party servers during the review process.

How does Atlas handle approval for changes it suggests in F#?

Atlas operates with a permission-gated system. Every tool call, including dotnet test or fantomas, requires your explicit allow, ask, or deny approval. All proposed F# file edits are presented as a unified diff for your review before Atlas writes or commits any changes.

Can Atlas help me find missed updates in F# code, like old constant names?

Absolutely. Atlas uses the grep tool to search your F# codebase for specific patterns. This is particularly useful for identifying instances where old constant names, feature flags, or stale copies should have been updated but were overlooked in the pull request.

Review a Pull Request in F# with Atlas in 2026

In 2026, Atlas empowers F# developers to review pull requests by going beyond line-by-line diffs, integrating directly with your F# solution's .fsproj files, running dotnet test (Expecto), and applying fantomas to ensure code quality and catch bugs that a simple diff might miss.

How Atlas Fetches and Understands F# Pull Request Diffs

In 2026, Atlas begins reviewing an F# pull request by leveraging its robust VCS layer to fetch the branch and produce a unified diff, much like a human reviewer would. This process involves using bash to get the raw patch and then read to pull the full F# source files, ensuring complete context beyond just the changed lines.

Atlas's review workflow for F# code starts by interacting with your Git repository. It uses its internal VCS layer, which exposes status, diff, diffRaw, and commits operations, to precisely identify the changes in a pull request. Unlike tools that only show line-by-line hunks, Atlas employs the bash tool to generate the initial raw patch, then uses the read tool to retrieve the entire content of each modified F# file. This approach is crucial for F# projects, where the significance of a change often extends beyond the immediate diff, requiring an understanding of surrounding modules, type definitions, or computation expressions that might not appear in a truncated view. By reading the full files, Atlas ensures it has all necessary context to analyze how a change in MyModule.fs might impact AnotherModule.fs even if AnotherModule.fs itself wasn't directly modified in the diff. This comprehensive file retrieval is a foundational step for Atlas's deeper F# specific analysis.

How Atlas Leverages F# Project Structure and Idioms for Deeper Analysis

Atlas, in 2026, goes beyond simple text analysis by deeply understanding F# project structure, particularly the .fsproj file. This allows Atlas to respect F#’s crucial file order compilation and map complex constructs like discriminated unions and Giraffe entry points, providing a more intelligent review than generic code analysis tools.

A key differentiator for Atlas when reviewing F# code is its ability to parse and interpret the .fsproj file. F# compilation is inherently order-dependent, meaning the sequence of <Compile Include="MyFile.fs" /> entries in your project file dictates how your code is built. Atlas reads this order directly from the .fsproj, ensuring its semantic understanding aligns with the F# compiler's perspective. This deep integration allows Atlas to correctly map declarations, understand the scope of modules, and track the flow of data through F# specific constructs like discriminated unions. For instance, if a change modifies a case in a discriminated union defined in DomainTypes.fs, Atlas can trace its usage through pattern matching in BusinessLogic.fs and ApiHandlers.fs. Furthermore, Atlas is designed to recognize and map common F# frameworks and patterns, such as Giraffe or Fable entry points, providing context-aware suggestions or checks that are highly relevant to the F# ecosystem. This intelligent indexing, built on AST declarations using tree-sitter, ensures Atlas doesn't just see lines of code, but understands the F# language's unique structure and idioms.

Verifying F# Code Changes with Toolchain Integration

Atlas, in 2026, integrates directly with the F# toolchain to verify code changes, ensuring correctness and adherence to F# best practices. This includes running dotnet test (Expecto) to validate functionality, using the lsp tool to check for broken references, and applying fantomas for consistent code formatting across all modified .fs files.

After understanding the F# diff and project context, Atlas proceeds to verify the changes using the actual F# toolchain. A critical step is running tests: Atlas can execute dotnet test with your chosen F# test runner, such as Expecto, behind a permission prompt. This ensures that any modifications haven't introduced regressions or broken existing functionality. For changes involving function signatures or type definitions, Atlas utilizes the lsp tool's findReferences operation. This is vital in F# where a change in SharedTypes.fs might break callers in Service.fs or Client.fs that are not directly part of the diff. Atlas proactively identifies these potential breaking changes. Additionally, to maintain code consistency, Atlas can run fantomas over all changed .fs files. This ensures that new or modified F# code adheres to the project's formatting standards, preventing style-related issues from entering the codebase. Atlas's ability to grep for old constant names or stale copies further enhances its verification capabilities, catching patterns that should have been updated but were missed.

Atlas's Safety and Approval Mechanisms for F# Code Reviews

Atlas, by 2026, incorporates robust safety and approval mechanisms into its F# pull request review workflow, ensuring human oversight and control. Every Atlas tool call, including dotnet test or fantomas, is permission-gated, and all proposed file edits are presented as a unified diff for explicit approval before Atlas writes any changes to your F# project.

Atlas is designed with a strong emphasis on user control and safety, particularly when interacting with your F# codebase. Before any tool, such as dotnet test or fantomas, is executed, Atlas presents a permission prompt, allowing you to allow, ask, or deny the operation. This permission-gated approach ensures that you, the F# developer, always retain ultimate control over what actions Atlas performs. Furthermore, Atlas operates with a read-only plan agent initially, drafting a comprehensive plan for the review before switching to a build agent that can propose changes. When Atlas suggests modifications, such as replacing a null check with an F# Option pipeline or adding Expecto tests, it computes a unified diff for every file edit. This diff is then surfaced for your explicit approval. You can review the proposed changes to your .fs files, paket.dependencies, or .fsproj before Atlas commits them. Atlas also snapshots file changes as Git patches, allowing edits to be easily diffed and rolled back if necessary, providing an additional layer of safety and auditability for your F# projects.

Step by step

01Atlas fetches the pull request branch and uses the bash tool to produce the raw diff, then the read tool to pull the full F# source files like MyModule.fs and DomainTypes.fs for complete context.
02Atlas indexes the F# code by AST declarations using tree-sitter, respecting the file order specified in your .fsproj file and mapping F# discriminated unions and modules.
03For every changed F# function signature in files like Service.fs, Atlas runs the lsp tool's findReferences operation to check for broken callers in other F# files that the diff might not show.
04Atlas uses the grep tool to search for patterns that should have been updated but were missed, such as old constant names or stale copies within your F# codebase.
05Atlas runs the F# tests by executing dotnet test (specifically targeting Expecto if configured) behind a permission prompt, reporting findings as a todowrite list ordered by severity.
06Atlas applies fantomas to all changed .fs files to ensure consistent F# code formatting, presenting the unified diff for approval before writing.
07Atlas presents a unified diff of all proposed changes to your F# files, allowing you to approve or reject edits before they are staged and committed to your F# project.

Frequently asked questions

How does Atlas handle F# file order dependencies during a PR review?: Atlas explicitly reads the <Compile Include="..." /> order from your .fsproj file. This ensures its internal code index, built with AST declarations, respects F#’s crucial compilation order, providing accurate semantic understanding during a pull request review.
Can Atlas run my F# Expecto tests as part of a pull request review?: Yes, Atlas can run your F# Expecto tests. It executes the dotnet test command behind a permission prompt, allowing you to validate functionality and catch regressions introduced by the pull request changes before approval.
How does Atlas ensure F# code formatting is consistent in a PR?: Atlas integrates with fantomas, the F# code formatter. It can automatically run fantomas over all changed .fs files in a pull request, presenting the formatted diff for your approval to ensure consistent styling across the codebase.
What if a F# signature change in a PR breaks code outside the diff?: Atlas addresses this by using the lsp tool's findReferences operation. For every changed F# function or type signature, Atlas proactively checks all callers across your F# solution, even those not directly in the diff, to identify potential breaking changes.
Does Atlas keep my F# code off third-party servers during review?: Yes, Atlas can build its code index using local Ollama embeddings. This capability ensures that your F# source code remains on your local machine, preventing it from being sent to third-party servers during the review process.
How does Atlas handle approval for changes it suggests in F#?: Atlas operates with a permission-gated system. Every tool call, including dotnet test or fantomas, requires your explicit allow, ask, or deny approval. All proposed F# file edits are presented as a unified diff for your review before Atlas writes or commits any changes.
Can Atlas help me find missed updates in F# code, like old constant names?: Absolutely. Atlas uses the grep tool to search your F# codebase for specific patterns. This is particularly useful for identifying instances where old constant names, feature flags, or stale copies should have been updated but were overlooked in the pull request.

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 F#: A Terminal-Native AI Coding Agent for .fsproj Solutions in 2026

Atlas is a terminal-native AI coding agent for F# in 2026. It respects .fsproj file order, maps discriminated unions, runs dotnet test behind a prompt, and runs Fantomas.

Self-review your working diff before committing in F# with Atlas in 2026

Catch F# coding mistakes before CI. Atlas helps F# developers in 2026 self-review uncommitted diffs, run `dotnet test (Expecto)`, and apply `fantomas` formatting, all from your terminal.

Extract a Shared Helper from Duplicated F# Code with Atlas in 2026

Refactor F# code in 2026 by extracting duplicated logic into a shared helper using Atlas. Leverage semantic search, automated refactoring, and F#-specific toolchain integration for clean, tested code.

Trace a runtime bug from a stack trace in F# with Atlas in 2026

In 2026, F# developers can use Atlas to trace runtime bugs from production stack traces directly to the responsible line of code and apply a fix, all without attaching a debugger. Atlas integrates with your F#

Run Atlas Headless in CI for F# Projects in 2026

F# developers in 2026 can run Atlas headless in CI pipelines to automate code tasks. Get machine-readable output, integrate with dotnet test (Expecto), NuGet, and fantomas for robust F# development.

Write unit tests for untested code in F# with Atlas in 2026

In 2026, Atlas helps F# developers add unit tests to existing modules, respecting .fsproj file order and using dotnet test (Expecto) and Fantomas.

Refactor a legacy F# module with Atlas in 2026

Safely refactor legacy F# modules using Atlas, the terminal-native AI coding agent. Pin behavior with `dotnet test (Expecto)`, apply changes, and ensure F# code quality with `fantomas`.

Browse this resource hub