How does Atlas handle OCaml project structure for diff review?

Atlas reads your OCaml project's Git working tree, including `dune-project` at the root, and indexes code by AST declarations using tree-sitter. This allows it to understand `dune` stanzas, `.mli` signatures, and `.ml` implementations, providing a context-aware diff review.

Can Atlas run `dune runtest` and interpret the results for OCaml?

Yes, Atlas can execute `dune runtest` via `bash` behind a permission prompt. It reads the compiler errors and test failures, such as those from `Alcotest` in your `test/` directory, back into its plan agent for you to address.

How does Atlas ensure OCaml code style with `ocamlformat`?

Atlas can run `ocamlformat` on your modified OCaml files. It then computes a unified diff of the formatting changes and surfaces it for your approval before writing, ensuring your code is style-clean according to your project's configuration.

What if I make an accidental change in an OCaml file with Atlas?

Atlas provides a session revert feature. It restores from a snapshot of your OCaml files, like `src/my_module.ml`, and ensures the session is not busy before reverting. This allows you to safely undo unwanted changes without manual intervention.

Can Atlas help me find temporary `Printf.printf` statements in my OCaml diff?

Absolutely. You can use Atlas's `grep` tool with `bash` to search your working diff for specific OCaml debugging patterns, such as `Printf.printf`, `failwith "DEBUG"`, or commented-out code blocks, helping you clean up before committing.

Does Atlas integrate with `opam` for OCaml package management?

Atlas can read the packages pinned in your `opam` switch and expose `opam` tools to the agent via Model Context Protocol servers. This allows Atlas to understand your OCaml project's dependencies and context.

How does Atlas prevent unintended changes from being committed in OCaml?

Atlas computes a unified diff for every file edit and surfaces it for approval before writing. Every Atlas tool call is permission-gated, and it drafts a plan in a read-only agent before switching to a build agent, giving you full control over OCaml code modifications.

Self-review Your OCaml Working Diff Before Committing with Atlas in 2026

OCaml developers in 2026 can effectively self-review their uncommitted diffs using Atlas, a terminal-native AI coding agent, to catch mistakes before they reach a reviewer or CI. Atlas integrates directly with your OCaml toolchain, allowing you to run `dune runtest`, apply `ocamlformat`, and manage `opam` dependencies, all while providing granular control over every change.

How Atlas Reads and Presents OCaml Diffs for Self-Review

Atlas provides a comprehensive view of your OCaml working diff, allowing developers in 2026 to read every change end to end, not just the files they remember touching. The agent's VCS layer surfaces the raw diff, ensuring no modification in your `dune-project` or `.ml` files goes unnoticed.

When preparing to commit OCaml code, Atlas empowers you to scrutinize your uncommitted changes with precision. Atlas reads the current state of your Git working tree, including branches, status, and the raw diff. This capability means you can use Atlas's `read` tool to examine the entire working diff, not just individual files. For instance, if you've modified `lib/my_feature.ml` and updated its interface in `lib/my_feature.mli`, Atlas presents a unified diff that encompasses both changes. This holistic view is crucial for OCaml, where changes in a `.ml` file often necessitate corresponding updates in its `.mli` signature, and a partial review could miss critical type mismatches or API regressions. Atlas's terminal-native TUI, rendered with SolidJS, ensures that this detailed diff is presented clearly, allowing you to focus on the OCaml code itself.

Inspecting OCaml File Changes and Their Surroundings with Atlas

Atlas allows OCaml developers to read each changed file in full, checking modifications against their surroundings, a critical step often overlooked in 2026. A standard diff can hide the context, but Atlas's `read` tool ensures you understand the impact of your changes on the broader OCaml codebase, including `dune` stanzas.

A common pitfall in self-review is focusing solely on the highlighted lines of a diff, neglecting the surrounding code that provides essential context. Atlas addresses this by enabling you to read each changed OCaml file in its entirety. For example, if you've refactored a function in `src/core/logic.ml`, Atlas lets you view the entire `logic.ml` file, allowing you to verify that your changes integrate correctly with adjacent functions, module types, and local definitions. This is particularly important in OCaml, where module boundaries and type inference can lead to subtle interactions. Atlas indexes code by AST declarations using tree-sitter, not blind line windows, which means it understands the structure of your OCaml code, from `let` bindings to `module` definitions, providing a more intelligent context for your review. This deep understanding helps you catch issues that a line-by-line diff might obscure, such as an unintended change in a `dune` build rule within your `dune-project` file.

Detecting Debugging Leftovers in OCaml Code with Atlas Grep

Before committing OCaml code, Atlas helps developers in 2026 identify and remove debugging leftovers like temporary logging or skipped tests. Atlas's `grep` tool can efficiently scan your working diff for common OCaml debugging patterns, preventing these artifacts from reaching your codebase or CI.

Debugging often involves introducing temporary code, such as `Printf.printf` statements, `failwith` calls for quick checks, or commenting out blocks of code. These elements, if committed, can degrade code quality or even break builds. Atlas's `grep` tool is invaluable here. You can instruct Atlas to `grep` your working diff for specific OCaml debugging patterns. For instance, you might search for `Printf.printf`, `failwith "DEBUG"`, `(* TODO: remove *)`, or `Alcotest.skip` within your `test/my_test.ml` files. Atlas executes these `bash` commands behind a permission prompt, ensuring you retain control. This proactive scanning helps you catch and remove these temporary additions, ensuring your OCaml codebase remains clean and production-ready. Atlas's ability to read the working tree means it operates on your uncommitted changes, providing immediate feedback.

Reverting Unwanted OCaml Changes with Atlas Session Revert

If an OCaml change should not have been made, Atlas offers a robust session revert mechanism, restoring from a snapshot and asserting the session is not busy first. This feature, available to developers in 2026, ensures that unwanted modifications to your `.ml` or `dune` files can be undone safely and reliably.

During the self-review process, you might discover that a particular change, perhaps an experimental refactor in `src/data/model.ml` or an incorrect `opam` package pin in your `dune-project`, is undesirable. Instead of manually undoing the changes, which can be error-prone, Atlas provides a session revert flow. This feature is backed by snapshots, meaning every edit Atlas made is recoverable. When you initiate a revert, Atlas first asserts that the session is not busy, preventing a half-written turn from being rolled back mid-flight. This safety mechanism ensures data integrity. Atlas snapshots file changes as Git patches, so edits can be diffed and rolled back with confidence. This capability is a significant advantage for OCaml developers, allowing for fearless experimentation and easy correction of missteps without disrupting the agent's workflow.

Running OCaml Tests and Formatting with Atlas Before Committing

Before committing OCaml code, Atlas facilitates running `dune runtest` and `ocamlformat` to ensure your changes are functionally correct and style-compliant. In 2026, Atlas can execute these essential OCaml toolchain commands, reading compiler errors and applying formatting, all within its terminal-native environment.

The final crucial steps in self-review involve verifying functionality and style. Atlas integrates direct with the OCaml toolchain to automate these checks. You can instruct Atlas to run `dune runtest` within your project, for example, in a `test/` directory containing `Alcotest` cases. Atlas executes this `bash` command, and if there are any compiler errors or test failures, it reads them back into its plan agent, allowing you to address them immediately. Following successful tests, Atlas can then apply `ocamlformat` to your modified OCaml files. This ensures that your code adheres to the project's style guidelines, preventing formatting-related comments during code review. Atlas's ability to compute a unified diff for every file edit and surface it for approval before writing means you can review the `ocamlformat` changes before they are applied, maintaining full control over your codebase. This comprehensive approach ensures your OCaml diff is both functionally sound and aesthetically clean before it ever reaches a reviewer or CI.

Step by step

01Use Atlas's `read` tool to examine the entire working diff, including changes across `dune-project`, `.ml`, and `.mli` files, ensuring a complete overview of your OCaml modifications.
02Instruct Atlas to `read` each changed OCaml file in full, verifying that your modifications integrate correctly with surrounding code and module definitions, especially in `src/` or `lib/` directories.
03Employ Atlas's `grep` tool with `bash` to scan your working diff for OCaml debugging leftovers, such as `Printf.printf`, `failwith "DEBUG"`, or `Alcotest.skip` in `test/` files.
04If an OCaml change is unwanted, use Atlas's session revert feature to restore from a snapshot, ensuring the session is not busy to safely undo modifications to your `dune` stanzas or source files.
05Ask Atlas to run `dune runtest` in your OCaml workspace, allowing it to read compiler errors and test failures from your `test/` directory, such as those from `Alcotest`.
06Have Atlas apply `ocamlformat` to your modified OCaml files, then review the unified diff of the formatting changes before approving them, ensuring style consistency.
07Approve the final OCaml diff presented by Atlas, which includes all functional and stylistic corrections, before Atlas stages and creates the commit on your behalf.

Frequently asked questions

How does Atlas handle OCaml project structure for diff review?: Atlas reads your OCaml project's Git working tree, including `dune-project` at the root, and indexes code by AST declarations using tree-sitter. This allows it to understand `dune` stanzas, `.mli` signatures, and `.ml` implementations, providing a context-aware diff review.
Can Atlas run `dune runtest` and interpret the results for OCaml?: Yes, Atlas can execute `dune runtest` via `bash` behind a permission prompt. It reads the compiler errors and test failures, such as those from `Alcotest` in your `test/` directory, back into its plan agent for you to address.
How does Atlas ensure OCaml code style with `ocamlformat`?: Atlas can run `ocamlformat` on your modified OCaml files. It then computes a unified diff of the formatting changes and surfaces it for your approval before writing, ensuring your code is style-clean according to your project's configuration.
What if I make an accidental change in an OCaml file with Atlas?: Atlas provides a session revert feature. It restores from a snapshot of your OCaml files, like `src/my_module.ml`, and ensures the session is not busy before reverting. This allows you to safely undo unwanted changes without manual intervention.
Can Atlas help me find temporary `Printf.printf` statements in my OCaml diff?: Absolutely. You can use Atlas's `grep` tool with `bash` to search your working diff for specific OCaml debugging patterns, such as `Printf.printf`, `failwith "DEBUG"`, or commented-out code blocks, helping you clean up before committing.
Does Atlas integrate with `opam` for OCaml package management?: Atlas can read the packages pinned in your `opam` switch and expose `opam` tools to the agent via Model Context Protocol servers. This allows Atlas to understand your OCaml project's dependencies and context.
How does Atlas prevent unintended changes from being committed in OCaml?: Atlas computes a unified diff for every file edit and surfaces it for approval before writing. Every Atlas tool call is permission-gated, and it drafts a plan in a read-only agent before switching to a build agent, giving you full control over OCaml code modifications.

Try Atlas in your terminal

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

Install Atlas

Related guides

Self-Review Your Working Diff Before Committing with Atlas (2026 Workflow)

How to self-review your working diff before committing with Atlas in 2026: bash produces the diff, read checks each file, grep finds leftovers, session revert undoes bad edits.

Atlas for OCaml: A Terminal-Native AI Coding Agent for dune and opam Projects in 2026

Atlas is a terminal-native AI coding agent for OCaml in 2026. It reads dune stanzas and .mli signatures, runs dune runtest behind a prompt, and finishes with ocamlformat.

Onboard to an Unfamiliar OCaml Codebase with Atlas in 2026

Quickly build a working mental model of any OCaml repository in 2026 using Atlas. Leverage `dune` build rules, `opam` switches, and `.mli` interface files for rapid understanding and safe code exploration.

Refactor a legacy module in OCaml with Atlas in 2026

Restructure an old OCaml module without breaking callers using Atlas. Map public surfaces, pin behavior with dune runtest, apply changes with apply_patch, and ensure style with ocamlformat.

Document an OCaml Module with a README using Atlas in 2026

Generate accurate, up-to-date README documentation for your OCaml modules in 2026 using Atlas. Leverage dune, opam, and ocamlformat for precise, traceable docs.

Trace a runtime bug from a stack trace in OCaml with Atlas in 2026

Pinpoint OCaml runtime bugs from production stack traces using Atlas in 2026. Leverage dune, opam, and ocamlformat to quickly identify and fix issues without a debugger attached.

Review a pull request in OCaml with Atlas in 2026

In 2026, Atlas helps OCaml developers review pull requests by fetching diffs, reading full files, checking .mli signatures, running dune runtest, and applying ocamlformat.

Write Unit Tests for Untested Code in OCaml with Atlas in 2026

Learn how Atlas helps OCaml developers in 2026 write unit tests for untested modules. Atlas uses dune runtest, opam, and ocamlformat to integrate with your existing OCaml workflow.

Browse this resource hub