How does Atlas understand my Clojure project's dependencies and aliases?

Atlas builds its code index by parsing your `deps.edn` file, allowing it to understand your project's dependencies, `:aliases`, and the structure of your Clojure namespaces. This deep understanding informs its contextual analysis and tool interactions.

Can Atlas run specific `kaocha` tests or just the entire suite?

Atlas uses its `bash` tool to execute `clojure -M:test`, which typically runs your entire `kaocha` test suite as configured in `deps.edn`. While it runs the full suite for comprehensive review, you can configure `deps.edn` aliases for more granular `kaocha` execution if needed.

How does Atlas ensure my Clojure code adheres to `cljfmt` conventions?

Atlas can invoke `cljfmt` via its `bash` tool, applying formatting fixes to changed Clojure files. It then presents a unified diff of these formatting changes for your approval, ensuring your `cljfmt` conventions are consistently applied.

What kind of permissions does Atlas ask for when reviewing Clojure code?

Atlas operates with permission-gated tool calls. For actions like running `clojure -M:test` or applying `cljfmt`, it will prompt you to `allow`, `ask`, or `deny` the execution, giving you explicit control over your Clojure environment.

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

Beyond the raw `git diff`, Atlas uses its `read` tool to pull the full contents of changed Clojure files. It also indexes code by AST declarations and uses `lsp findReferences` to check for impacts across namespaces, providing a holistic view.

Does Atlas keep my Clojure code on third-party servers for analysis?

No, Atlas can build its code index with local Ollama embeddings, ensuring your Clojure code remains on your machine and off third-party servers, maintaining privacy and security.

How does Atlas handle staging and committing changes in a Clojure workflow?

Atlas reads `git` branches, status, and diffs. It can stage and create commits on your behalf, but always surfaces a unified diff for approval before writing any file edits and before committing, giving you final control over your Clojure project's history.

Review a Pull Request in Clojure with Atlas in 2026

In 2026, Atlas empowers Clojure developers to review pull requests with unprecedented depth, moving beyond line-by-line diffs to catch subtle bugs that human eyes often miss. Atlas integrates directly with your existing Clojure toolchain, understanding `deps.edn` configurations, running `kaocha` tests via `clojure -M:test`, and applying `cljfmt` for consistent code style. It fetches the full context of changed files, checks for breaking signature changes across your codebase, and ensures all relevant patterns are updated, providing a comprehensive review before any code is committed.

How does Atlas get full context for Clojure pull request reviews?

In 2026, Atlas reviews a Clojure pull request by first fetching the branch and producing a raw diff using its VCS layer, which exposes git data. Unlike traditional tools, Atlas then uses its `read` tool to pull the full contents of changed files, not just the hunks, ensuring complete surrounding context is visible for a thorough review.

Atlas begins a Clojure pull request review by leveraging its robust VCS capabilities. It uses `bash` to interact with `git`, fetching the specific branch associated with the pull request and generating a raw patch. This initial step provides the foundational changes. However, a line-by-line diff often obscures crucial context. To overcome this, Atlas employs its `read` tool to retrieve the entire content of any file modified in the pull request. This means that if a change occurs in a `src/my_app/core.clj` file, Atlas reads the *entire* `core.clj` file, allowing it to analyze how the changes interact with surrounding code that might not be part of the immediate diff hunks. This comprehensive file access is vital for understanding the full impact of a Clojure change, especially when dealing with nested data structures or complex macro definitions where context is paramount. Atlas also builds its code index using AST declarations via tree-sitter, providing a deeper understanding of Clojure namespaces, aliases, and function definitions within your `deps.edn` project.

How does Atlas check for breaking changes in Clojure namespaces?

Atlas ensures Clojure code integrity by using its `lsp` tool's `findReferences` operation to detect breaking changes in 2026. For every modified function signature within a Clojure namespace, Atlas proactively checks all callers across the codebase, even those not directly touched by the diff, preventing silent regressions.

After understanding the full context of changed Clojure files, Atlas moves to proactively identify potential breaking changes. For any function or macro signature that has been altered in a file like `src/my_app/utils.clj`, Atlas invokes its `lsp` tool. Specifically, it uses the `findReferences` operation to locate every call site of that modified signature throughout the entire project. This is critical for Clojure, where changes in a core utility function could ripple through many dependent namespaces. A standard diff would only show the changes in `utils.clj`, but Atlas's `lsp` integration reveals if `src/my_app/api.clj` or `src/my_app/service.clj` now have broken calls due to the signature change. Furthermore, Atlas employs its `grep` tool to search for specific patterns that *should* have been updated but might have been missed. This includes old constant names, stale copies of code, or feature flags that were intended to be removed or modified, ensuring a thorough cleanup and consistency across the Clojure codebase.

How does Atlas run Clojure tests with Kaocha during a PR review?

Atlas integrates directly with the Clojure testing ecosystem in 2026, running `kaocha` tests to validate pull request changes. Before any commit, Atlas executes `clojure -M:test` via its `bash` tool, reporting findings as a `todowrite` list ordered by severity, ensuring all `deftest` cases under `test/` are thoroughly checked.

A crucial step in any Clojure pull request review is verifying that changes haven't introduced regressions and new features work as expected. Atlas automates this by directly invoking your project's test suite. Using its `bash` tool, Atlas executes the standard Clojure CLI command `clojure -M:test`, which in a well-configured `deps.edn` project, will run your `kaocha` test runner. This command targets all `deftest` cases defined within your `test/` directory, such as `test/my_app/core_test.clj`. Atlas waits for the test results and then processes them. Any failures or errors are compiled into a `todowrite` list, which is then presented to the developer, ordered by severity. This ensures that critical test failures are immediately visible and addressed. The execution of `clojure -M:test` is permission-gated, meaning Atlas will ask for your explicit approval before running external commands, maintaining transparency and control over your development environment.

How does Atlas ensure Clojure code formatting with cljfmt?

Atlas helps maintain consistent Clojure code style in 2026 by integrating with `cljfmt`, the community-standard formatter. Before finalizing a pull request, Atlas can apply `cljfmt` via its `bash` tool, ensuring that all new or modified code adheres to your project's indentation conventions and style guidelines.

Consistent code formatting is essential for readability and maintainability in any Clojure project. Atlas understands this and integrates direct with `cljfmt`, the widely adopted Clojure formatter. As part of the pull request review workflow, Atlas can be instructed to apply `cljfmt` to the changed files. This is achieved by using its `bash` tool to execute the appropriate `cljfmt` command, typically configured as an alias in your `deps.edn` file, such as `clojure -M:cljfmt check` or `clojure -M:cljfmt fix`. This step ensures that all new code in `src/my_app/new_feature.clj` or modifications to existing files like `src/my_app/core.clj` conform to the project's established indentation and style conventions. By automating `cljfmt` application, Atlas helps prevent formatting-related comments during human review, allowing developers to focus on the logic and correctness of the Clojure code. Atlas will present a unified diff of any formatting changes for your approval before writing them to disk, ensuring you always have the final say.

What safety features does Atlas offer for Clojure pull request reviews?

Atlas prioritizes safety and transparency in 2026 by implementing several robust features for Clojure pull request reviews. Every Atlas tool call, including `bash` commands for `kaocha` or `cljfmt`, is permission-gated, requiring explicit user approval before execution, ensuring developers retain full control over their `deps.edn` projects.

Atlas is designed with developer control and safety at its core, especially when interacting with your Clojure codebase. Before any tool call, such as running `clojure -M:test` with `kaocha` or applying `cljfmt` via `bash`, Atlas presents a permission prompt, allowing you to `allow`, `ask`, or `deny` the operation. This granular control ensures that no commands are executed without your explicit consent. Furthermore, Atlas drafts a comprehensive plan in a read-only plan agent, detailing its intended actions before switching to a build agent to execute them. This allows you to review the entire strategy for the pull request review, from fetching branches to running tests, before any changes are made. For every file edit Atlas proposes, it computes a unified diff and surfaces it for your approval, ensuring you can inspect and confirm every modification before it's written. Atlas also snapshots file changes as git patches, providing a robust mechanism for diffing edits and rolling back if necessary, offering an unparalleled level of safety and transparency for your Clojure development workflow.

Step by step

01Fetch the Clojure branch and produce the diff: Use Atlas's VCS layer to `bash` `git fetch` the pull request branch and then `git diff` to generate the initial patch.
02Read full Clojure files for context: Employ Atlas's `read` tool to retrieve the complete contents of all changed Clojure files, such as `src/my_app/core.clj`, ensuring context beyond the diff hunks is visible.
03Check for breaking Clojure signature changes: For every modified function or macro signature, use Atlas's `lsp` tool with `findReferences` to identify any callers in other Clojure namespaces that the diff does not show.
04Grep for unupdated Clojure patterns: Utilize Atlas's `grep` tool to search for old constant names, stale code copies, or feature flags that should have been updated or removed across your Clojure project.
05Run Clojure tests with Kaocha: Execute `clojure -M:test` via Atlas's `bash` tool, leveraging your `deps.edn` configuration to run `kaocha` against all `deftest` cases in your `test/` directory.
06Apply Clojure formatting with cljfmt: Have Atlas apply `cljfmt` using a `bash` command, such as `clojure -M:cljfmt fix`, to ensure all changed Clojure files adhere to your project's style guidelines.
07Review and approve Atlas's findings: Examine the `todowrite` list of findings, review the unified diffs for proposed changes, and approve or reject Atlas's suggested edits before they are committed.

Frequently asked questions

How does Atlas understand my Clojure project's dependencies and aliases?: Atlas builds its code index by parsing your `deps.edn` file, allowing it to understand your project's dependencies, `:aliases`, and the structure of your Clojure namespaces. This deep understanding informs its contextual analysis and tool interactions.
Can Atlas run specific `kaocha` tests or just the entire suite?: Atlas uses its `bash` tool to execute `clojure -M:test`, which typically runs your entire `kaocha` test suite as configured in `deps.edn`. While it runs the full suite for comprehensive review, you can configure `deps.edn` aliases for more granular `kaocha` execution if needed.
How does Atlas ensure my Clojure code adheres to `cljfmt` conventions?: Atlas can invoke `cljfmt` via its `bash` tool, applying formatting fixes to changed Clojure files. It then presents a unified diff of these formatting changes for your approval, ensuring your `cljfmt` conventions are consistently applied.
What kind of permissions does Atlas ask for when reviewing Clojure code?: Atlas operates with permission-gated tool calls. For actions like running `clojure -M:test` or applying `cljfmt`, it will prompt you to `allow`, `ask`, or `deny` the execution, giving you explicit control over your Clojure environment.
How does Atlas provide more context than a standard `git diff` for Clojure?: Beyond the raw `git diff`, Atlas uses its `read` tool to pull the full contents of changed Clojure files. It also indexes code by AST declarations and uses `lsp findReferences` to check for impacts across namespaces, providing a holistic view.
Does Atlas keep my Clojure code on third-party servers for analysis?: No, Atlas can build its code index with local Ollama embeddings, ensuring your Clojure code remains on your machine and off third-party servers, maintaining privacy and security.
How does Atlas handle staging and committing changes in a Clojure workflow?: Atlas reads `git` branches, status, and diffs. It can stage and create commits on your behalf, but always surfaces a unified diff for approval before writing any file edits and before committing, giving you final control over your Clojure project's history.

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 Clojure: A Terminal-Native AI Coding Agent for deps.edn and Kaocha in 2026

Atlas is a terminal-native AI coding agent for Clojure in 2026. It reads deps.edn aliases and namespace requires, runs clojure -M:test with Kaocha, and applies cljfmt.

Extract a Shared Helper from Duplicated Clojure Code with Atlas in 2026

Clojure developers in 2026 can use Atlas to identify and refactor duplicated logic into a shared helper, leveraging deps.edn, kaocha, and cljfmt for a streamlined workflow.

Automate GitHub Issue and Pull Request Triage in Clojure with Atlas in 2026

Streamline GitHub issue and pull request triage for your Clojure projects using Atlas in 2026. Automate responses safely with `deps.edn` and `kaocha`.

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

Catch your own mistakes in uncommitted Clojure code with Atlas in 2026. Leverage deps.edn, kaocha, and cljfmt for a robust self-review workflow, ensuring quality before CI.

Trace a Runtime Bug from a Stack Trace in Clojure with Atlas in 2026

Pinpoint and fix Clojure runtime bugs from production stack traces using Atlas, the terminal-native AI coding agent. Leverage `deps.edn`, `kaocha`, and `cljfmt` for rapid, verified fixes.

Add a Regression Test for a Clojure Bug Fix with Atlas in 2026

In 2026, Clojure developers use Atlas to lock in bug fixes with regression tests. Learn how Atlas integrates with deps.edn, kaocha, and cljfmt for robust testing workflows.

Run the Test Suite and Triage Failures in Clojure with Atlas in 2026

In 2026, Atlas helps Clojure developers efficiently run `kaocha` test suites, triage failures from `deps.edn` projects, and prioritize fixes using AI-powered tools.

Browse this resource hub