In 2026, Atlas helps F# developers write unit tests for untested code by reading the target module, identifying exported symbols, and then generating new test files that match existing repository conventions. It leverages the F# toolchain, including `dotnet test (Expecto)` for execution and `NuGet (dotnet add package)` for dependencies, ensuring the generated tests are immediately runnable and integrated into your project.
How does Atlas understand F# code for testing?
Atlas, in 2026, understands F# code by parsing `.fsproj` files to respect crucial file order and leveraging the `lsp` tool to enumerate exported symbols. This ensures that every public function within a module, including those defined with discriminated unions or computation expressions, is considered for test coverage.
Atlas begins the process of writing unit tests for F# code by first establishing a deep understanding of the project's structure. It runs within a solution containing an `.fsproj` file, which is critical for F# as compilation order is determined by the file order within this project file. Atlas reads this order directly from the `.fsproj`, ensuring that any generated test code or modifications align with the F# compiler's expectations. Furthermore, Atlas utilizes its `lsp` tool with the `documentSymbol` operation to meticulously enumerate all exported symbols from the target module. This capability allows Atlas to identify every public function, type, discriminated union, and module, guaranteeing that no public API surface is missed when drafting new unit tests. This precise understanding of F# constructs, from file order to specific language features like discriminated unions and computation expressions, enables Atlas to generate accurate and idiomatic F# test code.
How does Atlas match existing F# test conventions?
Atlas ensures new F# unit tests match existing repository conventions by using its `grep` tool to locate an existing test file, typically one using `Expecto`. This process, a core part of the 2026 workflow, allows Atlas to learn the project's framework, import style, and naming conventions before writing any new code.
To maintain consistency within an F# codebase, Atlas does not invent new testing conventions. Instead, it actively seeks out and adopts the existing patterns already present in your repository. After identifying the module under test, Atlas employs its `grep` tool to search for an existing test file. This search is often targeted at identifying files that import or use `Expecto`, the specified test runner for F#. By analyzing an existing `Expecto` test file, Atlas can discern the project's preferred test framework setup, its F# import style (e.g., `open` statements), and its naming conventions for test modules and functions. This crucial step ensures that any new test spec file written by Atlas with the `write` tool will direct integrate into the existing F# test suite, making the generated code feel native to the project and easier for F# developers to review and maintain.
How does Atlas write and run new F# unit tests?
Atlas writes new F# unit tests using its `write` tool, presenting a unified diff for approval before any changes are made to disk. Once written, Atlas executes these tests with the `bash` tool, running `dotnet test (Expecto)` to confirm functionality and identify failures, a critical step in the 2026 development cycle.
After understanding the F# module and its existing test conventions, Atlas proceeds to draft the new test spec file. This is accomplished using the `write` tool, which is designed to generate new code or modify existing files. Before any changes are committed to disk, Atlas computes and displays a unified diff, allowing the F# developer to review the proposed additions and approve them. This transparency ensures that the developer retains full control over the codebase. Once the new F# test file is written, the real validation begins. Atlas uses its `bash` tool to execute the test suite. For F# projects, this means running the command `dotnet test`, which, given the context, will invoke the `Expecto` test runner. Atlas captures the output of this command, reading any failures. If the output exceeds 2000 lines or 50 KB, it's truncated in the terminal, and the full log is saved to a file for detailed review. This iterative process of writing with `write`, running with `bash`, and reviewing failures is central to achieving a green test suite, with the `edit` tool available for making necessary adjustments and `todowrite` for managing progress on larger modules.
How does Atlas ensure F# code quality and safety?
Atlas ensures F# code quality and safety through multiple mechanisms, including permission-gated tool calls, unified diffs for every edit, and integration with `fantomas` for formatting. In 2026, every action, from adding a `NuGet (dotnet add package)` dependency to running `dotnet test`, requires explicit developer approval.
Safety and code quality are paramount when Atlas interacts with an F# codebase. Every Atlas tool call, whether it's `read`, `write`, `bash`, or `edit`, is permission-gated against allow, ask, and deny rules. This means that before Atlas can execute `dotnet add package` to include `Expecto`, or run `dotnet test`, it must first receive explicit permission from the developer. When Atlas drafts a plan, it does so in a read-only plan agent and asks for approval before switching to a build agent that can make changes. For every file edit, Atlas computes a unified diff and surfaces it for approval, ensuring that F# developers can review exactly what changes are being proposed before they are written to disk. Furthermore, Atlas integrates with `fantomas`, the standard F# formatter. After making changes to `.fs` files, Atlas can run `dotnet tool run fantomas` over them, ensuring that the newly added test code adheres to the project's formatting standards. Atlas also reads `git` branches, status, and diffs, and can stage and create commits on your behalf, with file changes snapshotted as `git` patches for easy diffing and rollback, providing a robust safety net for F# development.
Step by step
- 01Run `atlas` in your F# solution directory, ensuring an `.fsproj` file is present for Atlas to read F# file order.
- 02Use `atlas read <module_under_test.fs>` to load the F# module, then `atlas lsp documentSymbol <module_under_test.fs>` to enumerate all exported F# symbols for testing.
- 03Employ `atlas grep "Expecto"` to find an existing F# test file, learning the project's `Expecto` framework, import style, and naming conventions.
- 04If `Expecto` is not yet installed, use `atlas bash "dotnet add package Expecto --project <your_test_project.fsproj>"` to add the NuGet package, approving the permission prompt.
- 05Draft the new F# test file using `atlas write <new_test_file.fs>`, reviewing the unified diff and approving the changes before they land on disk.
- 06Execute the F# unit tests with `atlas bash "dotnet test --filter 'Category=NewTests'"` (or a similar `Expecto` filter) to run the newly added tests and observe failures.
- 07Iterate on the F# test code using `atlas edit <new_test_file.fs>` to fix failures, keeping track of progress with `todowrite` for large modules.
- 08Once tests are green, ensure F# code style with `atlas bash "dotnet tool run fantomas <new_test_file.fs>"` to format the new test file.
- 09Use `atlas git commit -m "Add F# unit tests for <module_name>"` to stage and commit your changes, leveraging Atlas's git integration.
Frequently asked questions
- How does Atlas handle F# file order in projects?
- Atlas explicitly reads the `.fsproj` file to understand and respect the F# compilation order. This ensures that any new test files or code modifications generated by Atlas are correctly placed and integrated into your F# project, preventing compilation issues related to file dependencies.
- Can Atlas add `Expecto` to my F# test project?
- Yes, Atlas can add `Expecto` to your F# test project. Using the `bash` tool, Atlas can execute `dotnet add package Expecto --project <your_test_project.fsproj>`. This action is permission-gated, requiring your approval before the `NuGet` package is added.
- How does Atlas ensure new F# tests match my existing style?
- Atlas ensures new F# tests match your existing style by using its `grep` tool to analyze an existing test file in your repository. It identifies the `Expecto` framework usage, import statements, and naming conventions, then applies these patterns when generating new F# test code with the `write` tool.
- Does Atlas run `fantomas` on F# code changes?
- Yes, Atlas can run `fantomas` on F# code changes. After modifying `.fs` files, Atlas can execute `dotnet tool run fantomas <file_path.fs>` via the `bash` tool. This ensures that all new or modified F# code adheres to your project's formatting standards, maintaining consistency.
- What F# test runners does Atlas support?
- Atlas is configured to work direct with `dotnet test (Expecto)` for F# projects. It understands how to generate `Expecto`-style tests and execute them using the standard `dotnet test` command, reading the output to identify test failures.
- How does Atlas protect my F# codebase from unwanted changes?
- Atlas protects your F# codebase through several safety mechanisms. Every tool call is permission-gated, requiring your explicit approval. It drafts plans in a read-only agent, and for every file edit, it computes and displays a unified diff for your review before writing changes. Atlas also integrates with `git` to snapshot changes, allowing for easy diffing and rollbacks.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Write Unit Tests for Untested Code with Atlas in 2026
How to write unit tests for untested code with Atlas in 2026: the lsp tool enumerates exported symbols, grep copies repo conventions, and bash actually runs the suite.
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.
Audit an F# Repository with Parallel Subagents in Atlas in 2026
Audit F# repositories in 2026 with Atlas's parallel subagents. Sweep code for problems using `dotnet test (Expecto)` and `fantomas` without blowing your main session's context window.
Migrate a deprecated API across every callsite in F# with Atlas in 2026
Efficiently migrate deprecated F# APIs across your entire codebase in 2026 using Atlas. Leverage dotnet test (Expecto), NuGet, and fantomas for a verified, complete transition.
Document a module with a README in F# with Atlas in 2026
Generate accurate, up-to-date READMEs for your F# modules using Atlas in 2026. Atlas leverages your .fsproj and real code to document public APIs, ensuring documentation reflects current implementation, not outdated
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`.
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.
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.