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

Atlas reads your `deps.edn` file, parsing `:paths`, `:aliases`, and other configurations to understand your Clojure project's structure and dependencies. This allows it to accurately navigate and reason about your codebase.

Can Atlas run `kaocha` tests in my Clojure project?

Yes, Atlas can execute `clojure -M:test` with `kaocha` behind a permission prompt. It understands the standard Clojure CLI test invocation and will surface the results for your review, ensuring test integrity.

How does Atlas ensure my Clojure code stays formatted correctly?

Atlas applies `cljfmt` to your Clojure code after making edits. It computes a unified diff for these formatting changes and presents it for your approval, ensuring your project's style conventions are maintained consistently.

What if I want to explore a specific Clojure namespace or definition?

You can use `atlas read src/my_app/my_namespace.clj` to view a specific file. To follow a definition, use `atlas lsp goToDefinition "my-app.my-namespace/my-function"`, which will navigate directly to its source.

Is Atlas safe to use with an unfamiliar Clojure codebase?

Yes, Atlas is designed for safety. It drafts plans in a read-only agent, uses permission-gated tool calls, and presents unified diffs for all proposed changes, including those from the `explore` subagent, before writing to disk.

Can Atlas help me understand Clojure macros or complex `->>` pipelines?

Atlas's AST-based indexing and semantic search capabilities help it understand the structure and intent of Clojure code, including macros and threading macros like `->>`. You can ask it to explain or trace such constructs.

How does Atlas handle local Clojure development environments with Ollama?

Atlas can build its code index using local Ollama embeddings, ensuring your Clojure codebase never leaves your machine. This keeps your proprietary code off third-party servers while still leveraging powerful AI capabilities.

Onboard to an Unfamiliar Clojure Codebase with Atlas in 2026

In 2026, Clojure developers can rapidly build a working mental model of an unfamiliar repository without reading every file by leveraging Atlas's semantic search and structured exploration tools. Atlas integrates directly with the Clojure CLI, understanding `deps.edn` configurations, `kaocha` test suites, and `cljfmt` formatting conventions to provide context-aware assistance.

How Atlas Finds Clojure Concepts with Semantic Search

In 2026, Atlas's `codebase_search` tool helps Clojure developers quickly grasp core concepts within an unfamiliar repository. It queries a semantic index built from your local code, identifying relevant Clojure namespaces and functions without requiring you to know specific filenames.

When you encounter a new Clojure project, understanding its core mechanisms is paramount. Instead of guessing which `.clj` files might contain the logic for, say, authentication, you can ask Atlas directly. For example, running `atlas codebase_search "how are requests authenticated in this Clojure application?"` will leverage Atlas's hybrid semantic and keyword retrieval. It processes your natural language query against the project's Abstract Syntax Tree (AST) declarations, returning ranked snippets from Clojure source files like `src/my_app/auth.clj` or `src/my_app/middleware.clj`. This approach ensures you start from meaning, not just filenames, making the onboarding process for Clojure projects driven by `deps.edn` significantly faster.

Mapping Clojure Project Structure with `glob` and `deps.edn`

Understanding the directory layout of a Clojure project is crucial, and Atlas's `glob` tool provides this insight in 2026. It quickly reveals the top-level structure, helping you infer package layout and naming conventions defined by `deps.edn` without opening a single file.

Clojure projects often follow conventions for organizing source code in `src/`, tests in `test/`, and resources in `resources/`. Before diving into specific files, a quick overview of the project's shape is invaluable. You can use `atlas glob "src/* test/* resources/* dev/*"` to see the primary directories and their immediate contents. This helps you understand how the project's `deps.edn` file might define source paths or aliases, for instance, `:paths ["src" "resources"]` or `:aliases {:dev {:extra-paths ["dev"]}}`. This initial structural scan, informed by real Clojure project layouts, provides a foundational mental model for navigating the codebase efficiently.

Deep Diving into Clojure Code with `read` and `lsp`

Once key Clojure files are identified, Atlas's `read` and `lsp` tools enable a focused deep dive into the code in 2026. You can inspect specific `.clj` files and follow function or macro definitions, tracing execution flow through namespaces and `require` statements.

After `codebase_search` points you to relevant Clojure files, you can use `atlas read src/my_app/core.clj` to view their contents directly within your terminal. To understand how a particular function or macro is defined or used, Atlas integrates with the Language Server Protocol (LSP). For example, if you see `(my-app.auth/authenticate request)` in `core.clj`, you can use `atlas lsp goToDefinition "my-app.auth/authenticate"` to jump directly to its definition, potentially in `src/my_app/auth.clj`. This allows you to follow the chain of `require` statements and `def` forms, building a precise mental model of the Clojure application's logic without manually searching through files.

Delegating Wide Clojure Code Sweeps to the `explore` Subagent

For broader investigations across a Clojure codebase, Atlas's `explore` subagent offers a powerful, read-only capability in 2026. This subagent can fan out work to parallel sessions, safely searching for patterns or usages without risking unintended modifications to your project.

When you need to perform a wide sweep, such as finding all `deftest` forms in the `test/` directory or identifying every `defmethod` for a specific protocol, the `explore` subagent is ideal. You can delegate such tasks using `atlas task explore "find all usages of integrant/start in the system map across all .clj files"`. The `explore` subagent operates with a deny-by-default permission set, allowing only safe operations like `grep`, `glob`, `read`, `bash`, `webfetch`, and `websearch`. This ensures that while it's looking for specific Clojure idioms or system component lifecycles, your codebase remains untouched, providing a secure environment for extensive code exploration.

Ensuring Safety and Review for Clojure Code Edits with Atlas

Atlas prioritizes safety and transparency when suggesting changes to a Clojure codebase in 2026. Every proposed edit, from adding a `deftest` to applying `cljfmt`, undergoes a multi-stage review process, ensuring you maintain full control over your project.

Before Atlas makes any changes, it drafts a plan in a read-only plan agent and asks for your approval. When it switches to a build agent, every tool call is permission-gated against allow, ask, and deny rules. For instance, if Atlas suggests adding a new `deftest` case to `test/my_app/core_test.clj`, it will present a unified diff for your review. Crucially, Atlas understands Clojure's formatting conventions. After any code modification, Atlas can apply `cljfmt` to ensure the diff adheres to your project's indentation and style guidelines, preventing formatting inconsistencies. You review and approve this `cljfmt` application before Atlas stages and creates a commit, giving you complete oversight of every change to your Clojure project.

Step by step

01Start Atlas in your Clojure project directory, ensuring a `deps.edn` file is present for Atlas to index.
02Ask Atlas a plain-language question about the codebase using `codebase_search`, for example: `atlas codebase_search "how are requests authenticated in this Clojure application?"`
03Run `glob` on top-level directories to understand the project layout and `deps.edn` structure: `atlas glob "src/* test/* resources/* dev/*"`
04Read the top-ranked Clojure files from `codebase_search`, then follow definitions with `lsp`: `atlas read src/my_app/auth.clj` followed by `atlas lsp goToDefinition "my-app.auth/verify-token"`
05Delegate wide sweeps to the read-only `explore` subagent for tasks like finding all `deftest` forms: `atlas task explore "find all deftest cases in the test/ directory"`
06Record open questions or findings as a `todowrite` list to carry context into future turns: `atlas todowrite "Investigate the :dev alias in deps.edn and its extra-paths"`
07If making a change, let Atlas draft a plan, for example, to add a new `deftest` case to `test/my_app/core_test.clj`.
08Review the unified diff for any proposed Clojure code edits, including automatic `cljfmt` applications, before approving Atlas to commit.

Frequently asked questions

How does Atlas understand my Clojure project's dependencies and aliases?: Atlas reads your `deps.edn` file, parsing `:paths`, `:aliases`, and other configurations to understand your Clojure project's structure and dependencies. This allows it to accurately navigate and reason about your codebase.
Can Atlas run `kaocha` tests in my Clojure project?: Yes, Atlas can execute `clojure -M:test` with `kaocha` behind a permission prompt. It understands the standard Clojure CLI test invocation and will surface the results for your review, ensuring test integrity.
How does Atlas ensure my Clojure code stays formatted correctly?: Atlas applies `cljfmt` to your Clojure code after making edits. It computes a unified diff for these formatting changes and presents it for your approval, ensuring your project's style conventions are maintained consistently.
What if I want to explore a specific Clojure namespace or definition?: You can use `atlas read src/my_app/my_namespace.clj` to view a specific file. To follow a definition, use `atlas lsp goToDefinition "my-app.my-namespace/my-function"`, which will navigate directly to its source.
Is Atlas safe to use with an unfamiliar Clojure codebase?: Yes, Atlas is designed for safety. It drafts plans in a read-only agent, uses permission-gated tool calls, and presents unified diffs for all proposed changes, including those from the `explore` subagent, before writing to disk.
Can Atlas help me understand Clojure macros or complex `->>` pipelines?: Atlas's AST-based indexing and semantic search capabilities help it understand the structure and intent of Clojure code, including macros and threading macros like `->>`. You can ask it to explain or trace such constructs.
How does Atlas handle local Clojure development environments with Ollama?: Atlas can build its code index using local Ollama embeddings, ensuring your Clojure codebase never leaves your machine. This keeps your proprietary code off third-party servers while still leveraging powerful AI capabilities.

Try Atlas in your terminal

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

Install Atlas

Related guides

Onboard to an Unfamiliar Codebase with Atlas in 2026

How to onboard to an unfamiliar codebase with Atlas in 2026: use codebase_search, glob, read, lsp, task, and todowrite to build a mental model fast.

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.

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.

Run Atlas Headless in CI for Clojure Projects in 2026

Automate Atlas in your Clojure CI/CD pipeline. Learn to run Atlas headless with `deps.edn`, `kaocha`, and `cljfmt` for machine-readable output and safe code changes in 2026.

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.

Review a Pull Request in Clojure with Atlas in 2026

Streamline Clojure pull request reviews in 2026 with Atlas, the terminal-native AI agent. Catch subtle bugs by leveraging `deps.edn`, `kaocha`, and `cljfmt` for deep context.

Refactor a legacy module in Clojure with Atlas in 2026

Modernize Clojure modules in 2026 without breaking callers. Atlas uses `deps.edn`, `kaocha`, and `cljfmt` to safely restructure code with AI-driven precision.

Upgrade a Clojure Dependency and Fix Breakage with Atlas in 2026

In 2026, Clojure developers use Atlas to efficiently upgrade dependencies in `deps.edn` projects, fixing compile and test failures with `kaocha` and `cljfmt`.

Browse this resource hub