In 2026, Clojure developers can automate GitHub issue and pull request triage using Atlas, integrating directly with their `deps.edn` projects. Atlas leverages the Clojure CLI for dependency management and can apply `cljfmt` for consistent code style, ensuring automated responses align with project standards and are safely executed.
How does Atlas automate GitHub triage for Clojure projects?
Atlas provides a first-class GitHub entrypoint in 2026, designed to integrate direct with Clojure projects managed by `deps.edn`. It reads inputs from the GitHub Actions environment, ensuring that automated triage for issues and pull requests is both efficient and secure.
Automating GitHub issue and pull request triage for Clojure projects begins by wiring the `atlas github` command into a GitHub Actions workflow. This command is specifically designed to consume inputs from the Actions environment. For instance, it requires a `MODEL` input, specified in `provider/model` form, to define which AI model Atlas should use for generating responses. Additionally, a `PROMPT` input is mandatory for specific event types that require a generated response; if missing, the handler fails with a clear message like 'PROMPT input is required for <event> events.' Atlas is built to understand Clojure project structures, reading `deps.edn` files to grasp namespaces, aliases, and REPL-shaped code, which informs its automated actions and suggestions. This deep integration ensures that any automated responses or proposed code changes are contextually relevant to your Clojure codebase.
How does Atlas ensure safety and trust for Clojure triage workflows?
Atlas enforces strict safety protocols for automated triage in 2026, checking the triggering actor's GitHub permissions before any action. It requires admin or write access, preventing unauthorized responses to Clojure issues or pull requests.
Ensuring safety and trust is paramount for any automated system interacting with a Clojure codebase on GitHub. Atlas implements several layers of security. First, it rigorously checks the triggering actor's collaborator permission, refusing to run if the user does not possess `admin` or `write` access to the repository. This prevents untrusted users from initiating automated actions. Second, to avoid accidental runs, the Atlas handler enforces that comments must explicitly mention the configured trigger before any processing begins. This 'require a mention' feature ensures that a stray comment cannot inadvertently start an Atlas run. Furthermore, Atlas is designed to handle context overflow gracefully. If a prompt or context becomes too large, a `ContextOverflowError` is caught by name and re-thrown as a 'prompt-too-large' message, explicitly listing the offending files. This prevents the agent from attempting to process an unmanageable amount of data, maintaining stability and transparency in your Clojure project's automated triage.
What Clojure tools does Atlas use for automated responses?
Atlas integrates deeply with the Clojure toolchain in 2026, understanding `deps.edn` for project structure and dependencies. When drafting responses or suggesting code changes, Atlas can leverage `cljfmt` to maintain consistent formatting.
Atlas is designed to be terminal-native and deeply aware of the Clojure ecosystem. For project management, it relies on `deps.edn (Clojure CLI)`, reading your project's dependencies, `:aliases`, and namespace requires to build a comprehensive understanding of your codebase. This allows Atlas to generate contextually appropriate responses or code suggestions that fit your Clojure project's specific setup. When Atlas proposes code edits, it can apply `cljfmt` to ensure that the generated diff adheres to your project's established indentation and formatting conventions. This means that automated changes will look as if a Clojure developer formatted them manually. While the triage workflow primarily uses Atlas's `bash`, `read`, `grep`, and `edit` tools for interacting with the environment and files, its underlying intelligence is informed by its ability to parse and understand Clojure code, making it a powerful assistant for maintaining high standards in your `deps.edn`-driven projects.
How does Atlas review and approve changes in Clojure projects?
Atlas provides a robust review and approval process for all automated actions in 2026, especially critical for Clojure codebases. It drafts a plan in a read-only agent and computes a unified diff for every file edit, surfacing it for explicit approval.
The safety of automated changes in a Clojure project is paramount, and Atlas incorporates a multi-stage review and approval mechanism. Before any modifications are made, Atlas drafts a comprehensive plan within a read-only plan agent. This allows you to review the proposed sequence of actions without any risk of unintended changes to your `deps.edn` project. Once a plan is approved, Atlas switches to a build agent. For every file edit, Atlas computes a unified diff, which is then surfaced for your explicit approval. This means you see exactly what changes Atlas intends to make to your Clojure source files, including any `cljfmt` applications, before they are written. Atlas also reads `git` branches, status, and diffs, and can stage and create commits on your behalf, ensuring that approved changes are integrated into your version control system with proper audit trails. This granular control over diffs and commits provides Clojure developers with confidence in the automated triage process.
Step by step
- 01Configure your Clojure project with a `deps.edn` file, defining dependencies and `:aliases` that Atlas can read.
- 02Set up a GitHub Actions workflow (`.github/workflows/triage.yml`) to invoke the `atlas github` command, ensuring it runs on relevant issue or pull request events.
- 03Provide the `MODEL` input in `provider/model` format (e.g., `ollama/codellama`) and the `PROMPT` input for event types requiring automated responses within your GitHub workflow configuration.
- 04Implement GitHub Actions permission checks to ensure the workflow only triggers for users with `admin` or `write` access to your Clojure repository, aligning with Atlas's internal security checks.
- 05Configure the Atlas handler to require an explicit mention (e.g., `@atlas triage`) in comments to trigger a run, preventing accidental automated responses to your Clojure issues.
- 06Allow Atlas to read your Clojure project's namespace requires and `:aliases` from `deps.edn` to provide contextually relevant automated responses or code suggestions.
- 07Review Atlas's proposed changes, which will include a unified diff for any Clojure file edits, potentially showing `cljfmt` applications for consistent style.
- 08Approve Atlas's generated diffs for Clojure files, allowing it to stage and commit changes to your repository, maintaining your project's integrity.
Frequently asked questions
- How do I integrate Atlas with my existing Clojure `deps.edn` project for triage?
- Atlas automatically reads your `deps.edn` file, including `:aliases` and namespace requires, to understand your Clojure project's structure and dependencies. You integrate it by calling the `atlas github` command within a GitHub Actions workflow, providing the necessary `MODEL` and `PROMPT` inputs.
- Can Atlas run `kaocha` tests as part of a GitHub triage workflow for Clojure?
- While Atlas can run `clojure -M:test` with Kaocha locally behind a permission prompt, the GitHub triage workflow focuses on responding to events and suggesting changes. For automated testing of suggested fixes, you would typically trigger separate CI checks that execute `kaocha` via `clojure -M:test` on the proposed branch.
- How does Atlas handle Clojure code formatting with `cljfmt` in automated responses?
- Atlas can apply `cljfmt` to any proposed Clojure code changes, ensuring that automated edits adhere to your project's established indentation and style conventions. This application happens before a unified diff is generated and presented for your approval, maintaining code quality.
- What happens if Atlas generates a response that's too long for GitHub in a Clojure context?
- Atlas explicitly catches `ContextOverflowError` and re-throws it as a 'prompt-too-large' message, listing the offending files. This prevents the agent from attempting to post an oversized response to a GitHub issue or pull request, ensuring clarity and preventing errors.
- How does Atlas ensure only trusted users can trigger automated triage for Clojure repositories?
- Atlas enforces strict security by checking the triggering actor's GitHub collaborator permission. It refuses to run if the user does not have `admin` or `write` access to the Clojure repository, preventing unauthorized automated actions. Additionally, it requires an explicit mention to trigger.
- Can Atlas suggest changes to Clojure `deps.edn` files or project configuration?
- Yes, Atlas is designed to understand `deps.edn` and can propose changes to dependencies, `:aliases`, or other project configurations. Any such changes would be presented as a unified diff for your review and explicit approval, just like changes to Clojure source files.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Automate GitHub Issue and Pull Request Triage with Atlas (2026 Workflow)
How to automate GitHub issue and pull request triage with Atlas in 2026: the atlas github command checks the actor has admin or write permission before it does anything.
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.
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.
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.
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.
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`.
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.
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.