Can Atlas generate new Spring Boot controllers in CI?

Yes, Atlas can generate new Spring Boot controllers or modify existing ones in CI. You can prompt Atlas to "Add a new REST endpoint" and it will use its `edit` tool to modify `.java` files and potentially `pom.xml`, all within your Maven-managed project, with changes visible in the JSON output.

How does Atlas handle `JUnit 5` tests in a headless Spring CI run?

Atlas can be instructed to add `JUnit 5` tests to your Spring project. After Atlas proposes changes, your CI pipeline can then execute these tests using `mvn test` to verify the correctness of the generated code, ensuring the new functionality works as expected.

What if Atlas needs to modify the `pom.xml` in a headless Spring CI?

Atlas can modify the `pom.xml` file in a headless Spring CI run, for example, to add a new dependency or plugin. These changes are presented as unified diffs in the JSON output, and the `edit` tool must be pre-approved in the permission configuration for Atlas to perform such modifications.

How do I ensure code style with `Spotless` after Atlas edits in Spring CI?

After Atlas makes edits in your Spring project, you can integrate `Spotless` into your CI pipeline. A common practice is to run `mvn spotless:apply` as a subsequent step to automatically format any new or modified code according to your project's defined style guidelines.

Can Atlas use local Ollama embeddings for Spring code in CI?

Yes, Atlas can build its code index with local Ollama embeddings, keeping your Spring code off third-party servers. This capability is fully supported in headless CI runs, enhancing data privacy and security for your Spring Boot applications by processing code locally.

How does Atlas's permission system work for headless Spring CI?

For headless Spring CI, Atlas's permission system requires pre-approval of tools like `bash`, `read`, `edit`, and `todowrite` in its configuration. This ensures that Atlas only performs actions explicitly allowed, as there is no interactive user to answer 'ask' prompts during an automated run.

What is the benefit of `--format json` for Spring CI pipelines?

The `--format json` option provides a raw, machine-readable event stream to stdout, which is crucial for Spring CI pipelines. This allows subsequent automated steps to parse Atlas's actions, proposed changes, and session status programmatically, enabling complex automation workflows and integration with other tools.

Can Atlas read Spring application properties files?

Yes, Atlas can read your Spring application properties files, along with controllers and services. This allows it to understand the configuration and structure of your Spring Boot application when generating or modifying code, ensuring context-aware and relevant changes.

Run Atlas Headless in CI for Spring Projects in 2026

In 2026, Spring developers can run Atlas headless in CI pipelines to automate code generation and refactoring, obtaining machine-readable output for integration with tools like JUnit 5 via `mvn test`, Maven, and Spotless. This non-interactive mode of Atlas is designed for automated environments, streaming events to stdout and exiting upon session completion, making it ideal for continuous integration workflows.

How to run Atlas headless in a Spring CI pipeline?

Running Atlas headless in a Spring CI pipeline in 2026 involves invoking the `atlas run` command with specific arguments to ensure non-interactive operation and machine-readable output. This approach is ideal for automating tasks like adding a REST endpoint or a JUnit test within your Maven-managed Spring Boot project.

To execute Atlas non-interactively within a Spring CI pipeline, the primary command is `atlas run`. By default, this command sends a single prompt, streams all session events to stdout, and exits when the session goes idle, making it perfect for automated environments. For machine-readable output, crucial for subsequent pipeline steps, you must include the `--format json` flag. This ensures that Atlas's actions, such as modifying a `pom.xml` or creating a new Spring controller `.java` file, are emitted as structured JSON events rather than prose. When setting up, ensure Atlas is running within your Spring Boot project, where it can read your controllers, services, and `application.properties` files, leveraging its understanding of the Maven build structure.

How does Atlas ensure safety and review in headless Spring CI?

Atlas ensures safety and review in headless Spring CI by implementing a robust permission-gated tool execution system and providing unified diffs for every proposed change. In 2026, this means all `bash`, `read`, `edit`, and `todowrite` tool calls are pre-approved via configuration, preventing unauthorized actions in your Spring Boot codebase.

For headless operation in a Spring CI pipeline, Atlas's permission system is critical. Every Atlas tool call, including `bash` for executing shell commands, `read` for accessing files, `edit` for modifying code, and `todowrite` for creating new files, is permission-gated. In a non-interactive environment, there is no user to answer 'ask' prompts, so all necessary tools must be pre-approved in Atlas's permission configuration using 'allow' rules. Before any changes are written, Atlas drafts a plan in a read-only plan agent. Once a plan is approved (implicitly by pre-approving tools in headless mode), it switches to a build agent. Atlas then computes a unified diff for every file edit, which is surfaced in the `--format json` output, allowing the CI system to review the exact changes before they are committed or applied to your Spring project. Atlas also snapshots file changes as git patches, enabling easy diffing and rollback.

What machine-readable output does Atlas provide for Spring CI?

Atlas provides machine-readable output for Spring CI through its `--format json` option, streaming a structured event log to stdout that downstream pipeline steps can parse. This capability, available in 2026, allows automated systems to process Atlas's actions, such as adding a new JUnit 5 test or modifying a Spring controller.

The `--format json` flag is essential for integrating Atlas into Spring CI pipelines that require programmatic interaction. When this flag is used with `atlas run`, Atlas streams a continuous sequence of JSON objects to stdout, representing every event in the session. This includes the initial prompt, the agent's thought process, tool calls (like `edit` to modify a `.java` file or `bash` to run a command), and the unified diffs of proposed file changes. A subsequent pipeline step can parse this JSON stream to extract specific information, such as the files Atlas modified, the content of new `JUnit 5` tests, or the status of a task. This structured output enables automated validation, reporting, and conditional execution of further steps, like running `mvn test` after Atlas generates new code for your Spring Boot application.

How does Atlas integrate with Spring's Maven build and testing?

Atlas integrates direct with Spring's Maven build and testing processes, understanding the structure of `pom.xml` files and the conventions of JUnit 5 tests. In 2026, Atlas can be instructed to add a new REST endpoint or generate a JUnit test, which can then be validated by running `mvn test` within the CI pipeline.

Atlas is designed to operate within a Spring Boot project that uses Maven as its package manager. It understands the significance of the `pom.xml` file, allowing it to read dependencies and project structure. Atlas can be prompted to perform tasks directly relevant to Spring development, such as adding a new REST endpoint to a controller, modifying a service bean, or generating a new `JUnit 5` test class. After Atlas makes these modifications using its `edit` tool, the CI pipeline can then invoke the standard Spring toolchain commands. For instance, `mvn test` will execute all `JUnit 5` tests, verifying the correctness and functionality of Atlas's generated or modified code. Additionally, to maintain code consistency, `Spotless` formatting can be applied by running `mvn spotless:apply` as a post-edit step, ensuring all changes adhere to the project's style guidelines.

How to manage Atlas sessions for iterative Spring CI tasks?

Managing Atlas sessions for iterative Spring CI tasks is facilitated by the `--continue`, `--session`, and `--fork` flags, allowing pipelines to build upon or replay previous Atlas runs. This feature, crucial for complex Spring Boot refactoring in 2026, ensures that an Atlas session can pick up exactly where it left off, even across different CI stages.

For complex or multi-stage Spring CI pipelines, Atlas provides robust session management capabilities. The `--session <session_id>` flag allows you to specify a particular session to interact with, while `--continue <session_id>` enables Atlas to resume a prior session, picking up exactly where it left off. This is invaluable for scenarios where a CI job might be interrupted or needs to be replayed from a specific point. The `--fork <session_id>` option allows you to create a new session that branches off from an existing one, preserving the context of the original while allowing for parallel exploration or alternative solutions. These flags ensure that iterative development tasks, such as a multi-step refactoring of Spring controllers or services, can be managed efficiently within a headless CI environment, building on previous Atlas actions without starting from scratch.

Step by step

01Ensure your Spring Boot project has a `pom.xml` and Atlas is configured to read your controllers, services, and application properties.
02Pre-approve necessary Atlas tools (`bash`, `read`, `edit`, `todowrite`) in your Atlas permission configuration for headless execution in CI.
03Invoke `atlas run` with your prompt, explicitly setting the model and specifying `--format json` for machine-readable output. For example: `atlas run "Add a new /status REST endpoint to my Spring Boot application" --format json --model github/copilot-gpt4`
04Parse the JSON event stream from stdout in a subsequent pipeline step to monitor Atlas's actions and proposed changes to your Spring codebase.
05If Atlas made changes, run `mvn test` to execute `JUnit 5` tests and validate the modifications within your Spring project.
06Optionally, apply `Spotless` formatting after Atlas edits by running `mvn spotless:apply` to maintain consistent code style in your Spring files.
07Use `atlas run --continue <session_id>` or `atlas run --fork <session_id>` to resume or branch from a previous Atlas session for iterative Spring development tasks in CI.

Frequently asked questions

Can Atlas generate new Spring Boot controllers in CI?: Yes, Atlas can generate new Spring Boot controllers or modify existing ones in CI. You can prompt Atlas to "Add a new REST endpoint" and it will use its `edit` tool to modify `.java` files and potentially `pom.xml`, all within your Maven-managed project, with changes visible in the JSON output.
How does Atlas handle `JUnit 5` tests in a headless Spring CI run?: Atlas can be instructed to add `JUnit 5` tests to your Spring project. After Atlas proposes changes, your CI pipeline can then execute these tests using `mvn test` to verify the correctness of the generated code, ensuring the new functionality works as expected.
What if Atlas needs to modify the `pom.xml` in a headless Spring CI?: Atlas can modify the `pom.xml` file in a headless Spring CI run, for example, to add a new dependency or plugin. These changes are presented as unified diffs in the JSON output, and the `edit` tool must be pre-approved in the permission configuration for Atlas to perform such modifications.
How do I ensure code style with `Spotless` after Atlas edits in Spring CI?: After Atlas makes edits in your Spring project, you can integrate `Spotless` into your CI pipeline. A common practice is to run `mvn spotless:apply` as a subsequent step to automatically format any new or modified code according to your project's defined style guidelines.
Can Atlas use local Ollama embeddings for Spring code in CI?: Yes, Atlas can build its code index with local Ollama embeddings, keeping your Spring code off third-party servers. This capability is fully supported in headless CI runs, enhancing data privacy and security for your Spring Boot applications by processing code locally.
How does Atlas's permission system work for headless Spring CI?: For headless Spring CI, Atlas's permission system requires pre-approval of tools like `bash`, `read`, `edit`, and `todowrite` in its configuration. This ensures that Atlas only performs actions explicitly allowed, as there is no interactive user to answer 'ask' prompts during an automated run.
What is the benefit of `--format json` for Spring CI pipelines?: The `--format json` option provides a raw, machine-readable event stream to stdout, which is crucial for Spring CI pipelines. This allows subsequent automated steps to parse Atlas's actions, proposed changes, and session status programmatically, enabling complex automation workflows and integration with other tools.
Can Atlas read Spring application properties files?: Yes, Atlas can read your Spring application properties files, along with controllers and services. This allows it to understand the configuration and structure of your Spring Boot application when generating or modifying code, ensuring context-aware and relevant changes.

Try Atlas in your terminal

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

Install Atlas

Related guides

Run Atlas Headless in CI with Atlas (2026 Workflow)

How to run Atlas headless in CI in 2026: atlas run sends one prompt and exits when the session goes idle, with --format json, --command, and --continue for pipeline steps.

Atlas for Spring in 2026

Atlas, the terminal native AI coding agent, empowers Spring developers in 2026 with intelligent code assistance, secure local embeddings, and transparent review processes for enhanced productivity.

Review a Pull Request in Spring with Atlas in 2026

In 2026, Spring developers use Atlas to review pull requests, leveraging its AI to analyze diffs, check `JUnit 5 via mvn test` results, and ensure code quality across controllers and services.

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

Design and review complex, multi-file changes in your Spring Boot project using Atlas's read-only plan agent, ensuring safety and precision before any code is modified. Leverage real Spring tools like Maven and JUnit 5.

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

In 2026, Spring developers use Atlas to add regression tests for bug fixes, ensuring code quality. Learn how Atlas integrates with Maven and JUnit 5 to lock in fixes with a red-green testing workflow.

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

Streamline Spring test triage in 2026 with Atlas. Turn JUnit 5 via Maven test output into prioritized root causes, leveraging Atlas's AI for efficient debugging.

Onboard to an Unfamiliar Spring Codebase in 2026 with Atlas

Quickly build a mental model of any Spring Boot repository in 2026 using Atlas. Leverage semantic search, understand Maven builds, and navigate controllers and services with terminal-native AI.

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

Catch your own mistakes in Spring Boot projects before committing. Atlas helps Spring developers in 2026 self-review uncommitted diffs, run JUnit 5 via mvn test, and check Spotless formatting.

Browse this resource hub