How does Atlas integrate with my existing Clojure deps.edn setup?

Atlas direct integrates by reading your deps.edn file, understanding your defined :aliases, namespace requires, and any integrant or component system maps, allowing it to operate within your project's specific configuration.

Can Atlas run specific kaocha test suites or only all tests?

Atlas, by exposing bash and understanding deps.edn aliases, can execute any kaocha command you would typically run via clojure -M:test. This includes running specific test suites or individual deftest cases as configured in your test/ directory.

What if cljfmt introduces changes I don't agree with?

Atlas computes a unified diff for every file edit, including those made by cljfmt. You will be prompted to approve these changes, giving you the final say. If the formatting is incorrect, you can adjust your .cljfmt.edn configuration.

How does Atlas prevent me from accidentally committing debugging code in Clojure?

Atlas can grep your working diff for common Clojure debugging patterns like (println ...), (comment ...), or ^:skip metadata on deftest forms, highlighting them for removal before you commit.

Is Atlas's session revert safe for complex Clojure projects?

Yes, Atlas's session revert is backed by git patches and asserts that the session is not busy before execution. This prevents rolling back a half-written turn, ensuring safe and reliable restoration of your Clojure project's state.

Can Atlas help me refactor Clojure code before committing?

While the primary focus here is self-review, Atlas's ability to search code with AST declarations and draft plans in a read-only agent means it can assist with refactoring tasks like threading a pipeline with ->> or adding deftest cases, which you then review via the diff.

Does Atlas support custom Clojure linters or only cljfmt?

Atlas is extensible through plugins and can expose any tool available via bash. While cljfmt is explicitly mentioned for formatting, if you have a custom linter runnable via clojure CLI, Atlas can be configured to execute it.

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

In 2026, Clojure developers can catch their own mistakes in uncommitted diffs before they reach a reviewer or CI by integrating Atlas into their workflow, leveraging its ability to read deps.edn configurations, execute clojure -M:test with kaocha, and apply cljfmt for consistent formatting. This terminal-native AI agent streamlines the self-review process, ensuring code quality and adherence to project standards.

How Atlas reads your Clojure working diffs for self-review

In 2026, Atlas provides a comprehensive view of your uncommitted Clojure changes by directly reading git branches, status, and diffs. This capability allows developers to review their working tree end-to-end, ensuring no modification, however small, goes unnoticed before a commit.

Atlas integrates deeply with your version control system, specifically git, to surface the raw diff of your current working tree. Instead of relying solely on memory of touched files, Atlas presents a unified diff for every file edit, allowing you to read each changed file in full. This is crucial for Clojure projects where a small change in a deps.edn alias or a def in a namespace can have cascading effects. Atlas's terminal-native TUI, rendered with SolidJS, ensures that this detailed diff is presented clearly, allowing you to check changes against their surroundings, which a simple git diff might obscure by only showing modified lines.

Running Clojure tests with Kaocha via Atlas before committing

Before committing any changes in 2026, Atlas can execute your Clojure project's tests using kaocha, ensuring all deftest cases pass. This critical step prevents regressions and validates new functionality, with Atlas prompting for permission before running clojure -M:test.

Atlas connects to Model Context Protocol servers and exposes their tools, including bash, to the agent. For Clojure projects, this means Atlas can run clojure -M:test to invoke kaocha, your preferred test runner. Atlas is configured to understand deps.edn aliases, allowing it to correctly set up the classpath and execute tests defined under test/. Every Atlas tool call is permission-gated, meaning you will receive an explicit prompt before Atlas runs the test command. This ensures that you maintain control, verifying that your changes, such as a new ->> pipeline or an updated integrant system map, do not introduce failures.

Ensuring Clojure code style with cljfmt and Atlas

In 2026, maintaining consistent Clojure code style is streamlined by having Atlas apply cljfmt to your working diff before committing. This ensures that your indentation conventions and formatting rules are automatically enforced, preventing style-related feedback during code review.

Atlas understands the importance of code consistency in Clojure projects. It can be instructed to apply cljfmt, the standard Clojure formatter, to your modified files. This process ensures that your code adheres to the project's established formatting guidelines, which are often configured in a .cljfmt.edn file. Atlas computes a unified diff for every file edit, and when cljfmt is applied, it surfaces these formatting changes for your approval. This step, performed before the final commit, means that your diff will only contain substantive code changes, not stylistic adjustments, making reviews more focused and efficient.

Identifying and removing debugging artifacts in Clojure code

Atlas, in 2026, helps Clojure developers identify and remove common debugging leftovers like temporary println statements or skipped deftest cases. By leveraging its grep capabilities, Atlas ensures that no unwanted artifacts make it into your committed code.

A common pitfall in self-review is forgetting to remove temporary debugging code. Atlas can assist by using grep to search for patterns indicative of debugging leftovers. For instance, it can look for (println ...) calls, (comment ...) blocks, or ^:skip metadata on deftest forms within your changed Clojure namespaces. Atlas's ability to search code with hybrid semantic and keyword retrieval, fused by reciprocal rank fusion, makes this process efficient. Once identified, Atlas can highlight these sections, allowing you to remove them before the code reaches a reviewer or CI, maintaining a clean and production-ready codebase.

Reverting unwanted Clojure changes with Atlas's session revert

If an unintended change is discovered during self-review in 2026, Atlas offers a robust session revert mechanism to restore your Clojure project from a snapshot. This feature ensures that unwanted modifications can be undone safely, preventing half-written turns from being rolled back mid-flight.

Atlas snapshots file changes as git patches, providing a powerful safety net. If, during your self-review of a Clojure diff, you identify a change that should not have been made perhaps an experimental def or an incorrect deps.edn alias Atlas's session revert can restore your working tree. This process is permission-gated and asserts that the session is not busy, preventing data loss. The revert flow is backed by these snapshots, meaning an unwanted change can be undone rather than requiring a manual, error-prone hand-revert, ensuring your Clojure project's integrity.

Step by step

01Initialize Atlas in your Clojure project: Run atlas in your terminal within a directory containing a deps.edn file, allowing Atlas to index your namespaces, :aliases, and any integrant or component system maps.
02Review the working diff: Ask Atlas to display the current git working diff. Read the entire diff, not just the files you remember touching, to understand all changes across your Clojure codebase.
03Inspect changed Clojure files: Read each modified .clj file in full, checking the changes against its surrounding context to ensure logical consistency and identify any unintended side effects.
04Scan for debugging artifacts: Instruct Atlas to grep for common Clojure debugging leftovers, such as (println ...), (comment ...), or ^:skip metadata on deftest forms, and remove them.
05Run Clojure tests with Kaocha: Prompt Atlas to execute your project's tests using clojure -M:test with kaocha. Approve the permission prompt and verify all tests pass.
06Apply Clojure formatting with cljfmt: Ask Atlas to apply cljfmt to your modified files. Review the resulting diff for formatting changes and approve them to maintain consistent style.
07Revert unwanted changes (if necessary): If any change should not have been made, use Atlas's session revert feature to restore from a previous snapshot, ensuring the session is not busy.
08Commit your changes: Once satisfied with the self-review, instruct Atlas to stage and create a commit with your approved Clojure changes.

Frequently asked questions

How does Atlas integrate with my existing Clojure deps.edn setup?: Atlas direct integrates by reading your deps.edn file, understanding your defined :aliases, namespace requires, and any integrant or component system maps, allowing it to operate within your project's specific configuration.
Can Atlas run specific kaocha test suites or only all tests?: Atlas, by exposing bash and understanding deps.edn aliases, can execute any kaocha command you would typically run via clojure -M:test. This includes running specific test suites or individual deftest cases as configured in your test/ directory.
What if cljfmt introduces changes I don't agree with?: Atlas computes a unified diff for every file edit, including those made by cljfmt. You will be prompted to approve these changes, giving you the final say. If the formatting is incorrect, you can adjust your .cljfmt.edn configuration.
How does Atlas prevent me from accidentally committing debugging code in Clojure?: Atlas can grep your working diff for common Clojure debugging patterns like (println ...), (comment ...), or ^:skip metadata on deftest forms, highlighting them for removal before you commit.
Is Atlas's session revert safe for complex Clojure projects?: Yes, Atlas's session revert is backed by git patches and asserts that the session is not busy before execution. This prevents rolling back a half-written turn, ensuring safe and reliable restoration of your Clojure project's state.
Can Atlas help me refactor Clojure code before committing?: While the primary focus here is self-review, Atlas's ability to search code with AST declarations and draft plans in a read-only agent means it can assist with refactoring tasks like threading a pipeline with ->> or adding deftest cases, which you then review via the diff.
Does Atlas support custom Clojure linters or only cljfmt?: Atlas is extensible through plugins and can expose any tool available via bash. While cljfmt is explicitly mentioned for formatting, if you have a custom linter runnable via clojure CLI, Atlas can be configured to execute it.

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 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.

Migrate a Deprecated API Across Every Callsite in Clojure with Atlas in 2026

Effortlessly migrate deprecated APIs across your Clojure codebase using Atlas. Leverage `deps.edn`, `kaocha`, and `cljfmt` for a complete, verified transition.

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.

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.

Document a Module with a README in Clojure with Atlas in 2026

Clojure developers in 2026 can use Atlas to generate accurate README documentation directly from their `deps.edn` projects, ensuring docs reflect current code and usage.

Onboard to an Unfamiliar Clojure Codebase with Atlas in 2026

In 2026, Clojure developers use Atlas to quickly build a mental model of new repositories. Leverage `deps.edn`, `kaocha`, and `cljfmt` with AI-powered code exploration.

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

Design complex, multi-file Clojure changes with Atlas's Plan agent in 2026. Get review-ready plans for your deps.edn projects before touching a single line of code.

Browse this resource hub