How does Atlas handle `Maven` dependency conflicts during a Quarkus upgrade?

Atlas executes `Maven` commands via `bash` and captures the full output, including any dependency conflict warnings or errors. It then uses this information to inform its plan, potentially suggesting manual intervention or specific `pom.xml` adjustments, always presenting changes for your approval.

Can Atlas fix build-time augmentation issues after a Quarkus library upgrade?

Yes, Atlas is aware of Quarkus's build-time augmentation. When fixing code, it aims to replace runtime reflection with build-time-friendly patterns, ensuring the class survives native-image compilation, as specified in its setup capabilities.

What if the upgraded library requires changes to `application.properties` in Quarkus?

Atlas can read and modify `application.properties` files. If the library's release notes (fetched via `webfetch`) indicate new configuration is needed, Atlas can propose and apply these changes, presenting them in the unified diff for your review.

How does Atlas ensure `JUnit 5 (@QuarkusTest)` cases are fixed correctly?

Atlas repeatedly runs `./mvnw test` via `bash` to validate fixes against your `JUnit 5 (@QuarkusTest)` suite. It uses the test output to identify failures and then applies `edit` operations, leveraging `lsp` to inspect new API signatures, until all tests pass.

Does Atlas support native-image compatibility during Quarkus dependency upgrades?

Atlas is designed with Quarkus's native-image constraints in mind. It prioritizes replacing runtime reflection with build-time-friendly patterns and ensures that code changes are compatible with the native-image compilation process, as outlined in its setup steps.

How does Atlas integrate with `Spotless` for Quarkus projects?

Atlas can execute `./mvnw spotless:apply` via `bash` as a final step before committing changes. This ensures that all code modifications made during the dependency upgrade adhere to your project's `Spotless` formatting rules, maintaining code consistency.

Can I roll back changes if a Quarkus dependency upgrade causes unexpected issues?

Yes, Atlas integrates with `git`. It snapshots file changes as `git` patches, allowing you to easily review, diff, and roll back any edits made during the upgrade process, providing a safety net for complex migrations.

Upgrade a Quarkus Dependency and Fix Breakage with Atlas in 2026

Atlas empowers Quarkus developers in 2026 to efficiently upgrade major dependencies and resolve all resulting compile and test failures by driving your existing toolchain, including `Maven` for package management, `JUnit 5 (@QuarkusTest)` for testing, and `Spotless` for code formatting. It automates the process from dependency bump to code repair and commit, ensuring your Quarkus application remains robust.

How Atlas upgrades Quarkus dependencies and fixes breakage

Atlas streamlines the process of upgrading a major dependency in your Quarkus project in 2026, addressing all compile and test failures by directly interacting with your `Maven` build system. It uses a multi-stage approach to ensure a robust and verifiable migration.

When you instruct Atlas to upgrade a dependency in a Quarkus project, it begins by executing `Maven` commands via `bash` to perform the upgrade. This initial step captures the full output, which Atlas can save to a file if it exceeds typical terminal limits, ensuring no information is lost. Following the upgrade, Atlas uses `webfetch` to retrieve the library's release notes and changelog. This crucial step provides context for breaking changes, allowing Atlas to understand the necessary code modifications rather than guessing. Atlas then drives your Quarkus build process by running `./mvnw clean install` through `bash`, letting the compiler enumerate all new errors. For each error, Atlas employs its `edit` tool, leveraging `lsp`'s `goToDefinition` operation to inspect the new signatures and API changes within the upgraded package. This precise approach ensures that fixes align with the actual breaking changes, respecting Quarkus's build-time augmentation and native-image constraints. The cycle of building, fixing, and re-testing continues until the project compiles and all `JUnit 5 (@QuarkusTest)` tests pass cleanly.

Concrete commands and files for Quarkus dependency upgrades

Atlas interacts with your Quarkus project using the same concrete commands and configuration files you use daily, ensuring familiarity and control over the upgrade process in 2026. It directly manipulates your `pom.xml` and executes standard `Maven` lifecycle goals.

To initiate a dependency upgrade, Atlas will execute a `Maven` command such as `./mvnw versions:use-latest-versions` or a specific version bump command, directly modifying your project's `pom.xml` file. This is the first step in introducing the new major version of the library. After the `pom.xml` is updated, Atlas runs `./mvnw clean install` via `bash` to trigger a full Quarkus build. This command compiles your application and runs any annotation processors, revealing compile-time errors that need addressing. For test failures, Atlas executes `./mvnw test`, which runs your `JUnit 5 (@QuarkusTest)` suite. Atlas reads the output of these commands to identify specific errors and test failures. When fixing code, Atlas understands Quarkus idioms, such as how CDI beans are declared or how JAX-RS resources are configured. It can also inspect and modify `application.properties` if the upgraded library introduces new configuration requirements. Before committing any changes, Atlas can apply your project's `Spotless` formatting rules by running `./mvnw spotless:apply`, ensuring code consistency and adherence to your team's standards.

Review and safety for Quarkus dependency migrations with Atlas

Atlas prioritizes safety and developer control throughout the dependency migration process, offering multiple layers of review and approval for every change made to your Quarkus codebase in 2026. Every tool call is permission-gated, and all edits are presented for your explicit approval.

Atlas operates with a robust permission system, where every tool call, including `bash` commands, `webfetch` requests, and `edit` operations, is permission-gated against `allow`, `ask`, and `deny` rules. This means you retain full control over what actions Atlas takes on your Quarkus project. Before making any modifications, Atlas drafts a plan in a read-only plan agent and asks for your approval before switching to a build agent that can execute changes. As Atlas fixes compile and test failures, it computes a unified diff for every file edit. These diffs are surfaced for your approval before any changes are written to disk. This allows you to review each modification, ensuring it aligns with your understanding of the required fixes and respects Quarkus-specific patterns, such as build-time friendly code for native-image compatibility. Atlas also reads `git` branches, status, and diffs, and can stage and create commits on your behalf, but only after you have reviewed and approved the entire set of changes. It snapshots file changes as `git` patches, providing a clear audit trail and the ability to roll back edits if needed, offering peace of mind during complex dependency upgrades.

Step by step

01Run the `Maven` dependency upgrade command (e.g., `./mvnw versions:use-latest-versions`) via Atlas's `bash` tool, capturing the full output.
02Fetch the upgraded library's release notes and changelog using Atlas's `webfetch` tool to understand breaking changes.
03Build the Quarkus project by executing `./mvnw clean install` via Atlas's `bash` tool to enumerate all compile-time errors.
04Fix each identified error using Atlas's `edit` tool, leveraging `lsp`'s `goToDefinition` to inspect new API signatures in the upgraded package.
05Re-run `JUnit 5 (@QuarkusTest)` tests with `./mvnw test` via Atlas's `bash` tool, repeating the fix-and-test cycle until all tests pass.
06Review the unified diff of all changes proposed by Atlas, ensuring Quarkus-specific idioms and `application.properties` modifications are correct.
07Let Atlas apply `Spotless` formatting by running `./mvnw spotless:apply` before staging and committing the changes via Atlas's `git` integration.

Frequently asked questions

How does Atlas handle `Maven` dependency conflicts during a Quarkus upgrade?: Atlas executes `Maven` commands via `bash` and captures the full output, including any dependency conflict warnings or errors. It then uses this information to inform its plan, potentially suggesting manual intervention or specific `pom.xml` adjustments, always presenting changes for your approval.
Can Atlas fix build-time augmentation issues after a Quarkus library upgrade?: Yes, Atlas is aware of Quarkus's build-time augmentation. When fixing code, it aims to replace runtime reflection with build-time-friendly patterns, ensuring the class survives native-image compilation, as specified in its setup capabilities.
What if the upgraded library requires changes to `application.properties` in Quarkus?: Atlas can read and modify `application.properties` files. If the library's release notes (fetched via `webfetch`) indicate new configuration is needed, Atlas can propose and apply these changes, presenting them in the unified diff for your review.
How does Atlas ensure `JUnit 5 (@QuarkusTest)` cases are fixed correctly?: Atlas repeatedly runs `./mvnw test` via `bash` to validate fixes against your `JUnit 5 (@QuarkusTest)` suite. It uses the test output to identify failures and then applies `edit` operations, leveraging `lsp` to inspect new API signatures, until all tests pass.
Does Atlas support native-image compatibility during Quarkus dependency upgrades?: Atlas is designed with Quarkus's native-image constraints in mind. It prioritizes replacing runtime reflection with build-time-friendly patterns and ensures that code changes are compatible with the native-image compilation process, as outlined in its setup steps.
How does Atlas integrate with `Spotless` for Quarkus projects?: Atlas can execute `./mvnw spotless:apply` via `bash` as a final step before committing changes. This ensures that all code modifications made during the dependency upgrade adhere to your project's `Spotless` formatting rules, maintaining code consistency.
Can I roll back changes if a Quarkus dependency upgrade causes unexpected issues?: Yes, Atlas integrates with `git`. It snapshots file changes as `git` patches, allowing you to easily review, diff, and roll back any edits made during the upgrade process, providing a safety net for complex migrations.

Try Atlas in your terminal

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

Install Atlas

Related guides

Upgrade a Dependency and Fix the Breakage with Atlas (2026 Workflow)

How to upgrade a dependency and fix the breakage with Atlas in 2026: bash drives the package manager, webfetch pulls the release notes, edit fixes each compiler error.

Atlas for Quarkus in 2026

Atlas is a terminal-native AI coding agent for Quarkus in 2026. It reads CDI beans and JAX-RS resources, then runs ./mvnw test behind a permission prompt.

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

Streamline your Quarkus applications in 2026 by extracting duplicated logic into shared, tested helpers using Atlas. Find semantic duplicates, refactor with confidence, and ensure code quality with Maven and JUnit 5.

Refactor a legacy module in Quarkus with Atlas in 2026

Streamline Quarkus module refactoring in 2026 with Atlas. Safely restructure old code, maintain behavior, and prevent breaking callers using Maven, JUnit 5, and Spotless.

Debug a Single Failing Test in Quarkus with Atlas in 2026

Pinpoint and fix failing Quarkus tests efficiently with Atlas. Leverage JUnit 5, Maven, and Spotless for a streamlined debugging workflow in 2026.

Run the test suite and triage the failures in Quarkus with Atlas in 2026

In 2026, Quarkus developers use Atlas to efficiently run JUnit 5 (@QuarkusTest) suites, parse extensive failure logs, and prioritize distinct root causes for rapid resolution.

Trace a runtime bug from a stack trace in Quarkus with Atlas in 2026

Pinpoint and fix Quarkus runtime bugs from production stack traces using Atlas, the terminal-native AI agent. Leverage Maven, JUnit 5, and Spotless for rapid resolution.

Write Unit Tests for Untested Quarkus Code with Atlas in 2026

In 2026, use Atlas to write robust unit tests for untested Quarkus modules. Atlas understands your existing JUnit 5 (@QuarkusTest) and Maven conventions, ensuring new tests integrate direct.

Browse this resource hub