How does Atlas handle Quarkus build-time augmentation when searching for code?

Atlas indexes code by AST declarations using Tree-sitter, which allows it to understand the structure and purpose of Quarkus components, even those modified by build-time augmentation. This semantic understanding helps locate behavior implementations that might be difficult to find with simple keyword searches.

Can Atlas find specific JAX-RS resources or CDI beans in my Quarkus project?

Yes, Atlas's `codebase_search` tool can identify JAX-RS resources and CDI beans. By understanding the AST declarations, Atlas can semantically link your description of a behavior to the relevant Quarkus components, even if you don't use their exact class names.

What Quarkus tools does Atlas integrate with for development workflow?

Atlas integrates directly with core Quarkus tools and practices. It works with `Maven` for project management, understands `pom.xml` and `application.properties`, and can add and run `JUnit 5 (@QuarkusTest)` cases. It also respects `Spotless` for code formatting.

How does Atlas ensure code quality and safety when making changes in a Quarkus codebase?

Atlas prioritizes safety by drafting a read-only plan for review, permission-gating every tool call, and presenting a unified diff for every proposed file edit. This allows you to approve or reject changes, ensuring code quality and preventing unintended modifications to your Quarkus project.

Can Atlas help me understand the impact of changes in `application.properties`?

Yes, Atlas can help. You can use `grep` to find specific properties in `application.properties` and then use the `lsp` tool's `findReferences` on related code symbols to understand how those properties are consumed and impact behavior within your Quarkus application.

Does Atlas support local code indexing for Quarkus projects?

Yes, Atlas can build its code index with local Ollama embeddings. This capability ensures that your proprietary Quarkus code remains on your local machine, addressing data privacy and security concerns by keeping it off third-party servers.

How does Atlas handle large Quarkus projects with many Maven modules?

Atlas is designed to handle large codebases. Its `grep` tool can filter results by path, and the `lsp` tool's `workspaceSymbol` can locate declarations across multiple Maven modules, making it efficient to navigate and understand complex Quarkus projects.

Locate where a behavior is implemented in Quarkus with Atlas in 2026

In 2026, Atlas helps Quarkus developers locate where a behavior is implemented by combining semantic codebase search, precise `grep` operations, and `lsp` tool integration to navigate your Maven-managed project, identifying the exact file and symbol responsible for any observed behavior. This approach ensures you find the right code, even when you only know what the software does, not what the code is called, respecting Quarkus's build-time augmentation and native-image constraints.

How Atlas finds Quarkus behavior without knowing code names

Atlas employs 3 complementary strategies to locate behavior implementations in your Quarkus codebase, even when you only know the functional outcome. It fuses semantic and keyword retrieval, leveraging AST declarations from Tree-sitter for precise indexing, ensuring that your natural language descriptions yield relevant code candidates.

When you describe a behavior in your Quarkus application to Atlas, it doesn't just perform a keyword search. Instead, Atlas's `codebase_search` tool uses hybrid semantic and keyword retrieval, fused by reciprocal rank fusion. This means it understands the meaning behind your words, not just the exact text. Atlas indexes your code by AST declarations using Tree-sitter, which allows it to identify relevant CDI beans, JAX-RS resources, or other Quarkus components based on their structure and purpose, even if your description doesn't match the exact method or class name. This is particularly powerful in Quarkus, where build-time augmentation can sometimes obscure runtime behavior, making traditional keyword searches less effective. Atlas can build its code index with local Ollama embeddings, keeping your proprietary Quarkus code off third-party servers.

Confirming Quarkus code candidates with `grep` and file inspection

To confirm a candidate file in your Quarkus project, Atlas leverages `grep` with real regex patterns, allowing for precise filtering of over 100,000 lines of code in large projects. This step is crucial for validating semantic search results against exact text matches, ensuring the identified code aligns with specific configuration or string literals.

After `codebase_search` provides initial candidates, Atlas uses its `grep` tool to confirm the findings. This tool runs through `ripgrep` and accepts real regex patterns, along with include and path filters, allowing you to narrow down results to specific Quarkus modules or file types, such as `src/main/java/**/*.java` or `application.properties`. For instance, if you're looking for a specific configuration value, `grep` can quickly locate its usage in `application.properties`. Once a promising file is identified, you can use the `read` tool to open it. If you make a wrong guess, Atlas provides a 'File not found' error along with a 'Did you mean' list, preventing wasted time on incorrect paths and ensuring you always work with valid Quarkus file references.

Navigating Quarkus symbol graphs with the `lsp` tool

Navigating the symbol graph in a Quarkus application is crucial for understanding call paths, and Atlas's `lsp` tool provides 2 key operations: `findReferences` and `workspaceSymbol`. These operations allow you to jump directly to declarations or see every callsite of a method, essential for tracing behavior through CDI injections or JAX-RS endpoints.

Once you've identified a potential symbol in a Quarkus file, Atlas's `lsp` tool becomes invaluable. Using `findReferences`, you can see every callsite of a method or field, which is critical for understanding how a specific behavior is invoked across your Quarkus application. This helps trace the flow from a JAX-RS endpoint to a CDI bean, for example. Alternatively, if you know the name of a symbol but not its exact location, `workspaceSymbol` allows you to jump directly to its declaration. This is particularly useful in large Maven-managed Quarkus projects where classes might be spread across multiple modules. Atlas connects to Model Context Protocol servers, exposing their tools to the agent, which enhances its `lsp` capabilities for a richer Quarkus development experience.

Atlas's safety and review process for Quarkus code changes

Atlas ensures safety and transparency in 2026 by drafting a read-only plan and presenting a unified diff for every proposed change before writing to your Quarkus codebase. Every Atlas tool call is permission-gated against allow, ask, and deny rules, providing developers with complete control over automated modifications.

Before Atlas makes any changes to your Quarkus project, it operates with a strong emphasis on safety and developer control. Atlas first drafts a plan in a read-only plan agent and asks for your approval before switching to a build agent. This allows you to review the proposed steps for locating or modifying behavior. For any actual code edits, Atlas computes a unified diff for every file and surfaces it for your approval. This means you see exactly what changes Atlas intends to make, such as replacing runtime reflection with a build-time-friendly pattern for native-image compatibility, or adding `@QuarkusTest` cases with `RestAssured`. You can review the diff, then let Atlas apply `Spotless` for formatting before it commits. Atlas also snapshots file changes as git patches, so edits can be diffed and rolled back, providing a robust safety net for your Quarkus development workflow.

Step by step

01Describe the observed behavior in your Quarkus application to Atlas's `codebase_search` tool, focusing on its function rather than specific class names or methods.
02Review the semantic search results for candidate declarations, which might include CDI beans or JAX-RS resources, even if your query didn't use their exact names.
03Confirm potential candidates using Atlas's `grep` tool with a real regex, applying include filters like `src/main/java/**/*.java` to narrow down to relevant Quarkus source files.
04Open the most promising Quarkus file with the `read` tool. If the path is incorrect, Atlas will provide a 'File not found' error and 'Did you mean' suggestions.
05Utilize the `lsp` tool's `findReferences` operation on a symbol within the opened file to trace its usage across your Maven-managed Quarkus project.
06Alternatively, use `lsp workspaceSymbol` to jump directly to the declaration of a known Quarkus symbol by name, regardless of its file location.
07Summarize the call path and implementation details back to the user, providing concrete file and line references within your Quarkus codebase.
08Review any proposed changes or additions, such as new `@QuarkusTest` cases or `application.properties` modifications, via Atlas's unified diff before approval.

Frequently asked questions

How does Atlas handle Quarkus build-time augmentation when searching for code?: Atlas indexes code by AST declarations using Tree-sitter, which allows it to understand the structure and purpose of Quarkus components, even those modified by build-time augmentation. This semantic understanding helps locate behavior implementations that might be difficult to find with simple keyword searches.
Can Atlas find specific JAX-RS resources or CDI beans in my Quarkus project?: Yes, Atlas's `codebase_search` tool can identify JAX-RS resources and CDI beans. By understanding the AST declarations, Atlas can semantically link your description of a behavior to the relevant Quarkus components, even if you don't use their exact class names.
What Quarkus tools does Atlas integrate with for development workflow?: Atlas integrates directly with core Quarkus tools and practices. It works with `Maven` for project management, understands `pom.xml` and `application.properties`, and can add and run `JUnit 5 (@QuarkusTest)` cases. It also respects `Spotless` for code formatting.
How does Atlas ensure code quality and safety when making changes in a Quarkus codebase?: Atlas prioritizes safety by drafting a read-only plan for review, permission-gating every tool call, and presenting a unified diff for every proposed file edit. This allows you to approve or reject changes, ensuring code quality and preventing unintended modifications to your Quarkus project.
Can Atlas help me understand the impact of changes in `application.properties`?: Yes, Atlas can help. You can use `grep` to find specific properties in `application.properties` and then use the `lsp` tool's `findReferences` on related code symbols to understand how those properties are consumed and impact behavior within your Quarkus application.
Does Atlas support local code indexing for Quarkus projects?: Yes, Atlas can build its code index with local Ollama embeddings. This capability ensures that your proprietary Quarkus code remains on your local machine, addressing data privacy and security concerns by keeping it off third-party servers.
How does Atlas handle large Quarkus projects with many Maven modules?: Atlas is designed to handle large codebases. Its `grep` tool can filter results by path, and the `lsp` tool's `workspaceSymbol` can locate declarations across multiple Maven modules, making it efficient to navigate and understand complex Quarkus projects.

Try Atlas in your terminal

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

Install Atlas

Related guides

Locate Where a Behavior Is Implemented with Atlas in 2026

How to locate where a behavior is implemented with Atlas in 2026: codebase_search for meaning, grep for exact text, and the lsp tool for the symbol graph.

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.

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

Catch your own mistakes in uncommitted Quarkus diffs using Atlas. Integrate with Maven, JUnit 5 (@QuarkusTest), and Spotless for a robust self-review workflow.

Onboard to an Unfamiliar Quarkus Codebase with Atlas in 2026

Quickly build a working mental model of any Quarkus codebase in 2026 with Atlas. Leverage semantic search, AST indexing, and direct interaction with Maven, JUnit 5 (@QuarkusTest), and Spotless to understand unfamiliar

Audit a Quarkus Repo with Parallel Subagents in Atlas in 2026

Sweep your Quarkus repository for problems without blowing your context window. Atlas uses parallel subagents, JUnit 5, Maven, and Spotless for efficient, safe audits.

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