JetBrains Junie Goes GA: AI Moves Beyond Code Generation to Control the Debugger

JetBrains announced that its AI coding agent Junie has exited beta and is now generally available. The upgrade shifts Junie's goal from merely writing Java code to leveraging IntelliJ IDEA’s project index, build configuration, test tools, database integration, and, crucially, the Debugger to perform complete engineering tasks.

The most significant change for Java developers is Junie's ability to operate the IDE’s debugger: it can start or take over a debug session, set breakpoints, inspect call stacks, thread states, and expression results, and even step into dependency libraries, SDKs, and decompiled class files. This moves AI‑assisted problem solving from "reading code and guessing the cause" to "entering the debugger to collect runtime evidence"—a shift especially valuable for complex Spring Boot projects.

Why Debugger Access Matters

Generating a Spring Boot controller is trivial for AI, but real‑world issues often stem from unexpected runtime behavior, such as null values appearing only with specific data, flaky unit tests, transaction rollbacks not occurring, or Feign clients failing in certain environments. Static code inspection cannot reliably resolve these problems; developers need to observe actual execution state.

Traditional AI coding agents resort to inserting extensive logging statements, re‑running tests, and iterating—a trial‑and‑error loop that is inefficient and leaves noisy code. In contrast, a debugger allows observation without modifying production code, enabling precise inspection of variables, threads, and conditional branches.

Example Debugging Task

Consider an OrderBatchServiceTest where processing a batch of orders succeeds on the first iteration but fails on the second. The code snippet is:

public void processOrders(List<Order> orders) {
  for (Order order : orders) {
    processSingleOrder(order);
  }
}

An AI agent might list many possible causes based solely on the code. Instead, Junie can be instructed to debug the failing test without modifying code, set a breakpoint at processSingleOrder, and compare the state of the Order object, OrderContext, ThreadLocal data, call stack, and the actual implementation class between the first and second iterations. Once runtime evidence identifies, for example, residual ThreadLocal data, the root cause becomes clear and the fix can focus on context cleanup.

Plan Mode Enhancements

Junie’s Plan Mode now generates a structured plan before any code changes. The plan, saved under .junie/plans, includes product requirements, technical design, delivery phases, and test strategy. Developers review and edit this plan in the IDE before the agent proceeds, preventing premature or misdirected code modifications.

For instance, migrating a synchronous order notification to RocketMQ requires a plan covering current call‑chain analysis, message boundaries, transaction‑message consistency, idempotence design, retry handling, gray‑release steps, rollback strategy, and test scope. The agent waits for developer approval before implementing any changes.

Impact on Code Review and Async Tasks

Traditional pull‑request reviews focus on static code aspects. With debugger access, Junie can run relevant tests, set breakpoints, and verify runtime behavior before commenting, turning AI review from pattern‑based suggestions to evidence‑based risk assessment.

Junie also supports asynchronous long‑running tasks, allowing developers to launch extensive operations (e.g., Spring Boot version upgrades, Bean migrations, large‑scale refactoring) and monitor progress remotely, freeing developers from constant terminal supervision.

IDE‑Level Project Understanding

Unlike file‑level agents, Junie leverages IntelliJ IDEA’s semantic index, recognizing classes, methods, beans, modules, dependencies, and run configurations. This deep project awareness enables accurate impact analysis, such as determining all modules that depend on a shared DTO before modifying it.

Database Integration and Security Considerations

Junie can connect to databases configured via DataGrip or the JetBrains Database plugin, allowing queries, SQL modifications, and result verification within the same session. However, the article warns against granting production‑level privileges; instead, use local or test databases with read‑only accounts and require explicit developer confirmation for write operations.

Recommended Starting Tasks for Java Teams

Unit test failure analysis using the debugger to pinpoint root causes.

Spring Boot startup failure investigations (bean injection, profile configuration, Feign scanning, dependency conflicts).

Adding tests to legacy code with a generated test plan.

Small‑scale refactoring, such as extracting private methods while preserving behavior.

Pull‑request review that includes runtime verification of transaction, MQ idempotence, SQL, and interface compatibility risks.

These tasks leverage Junie’s IDE integration without handing over full project control.

Best Practices and Caveats

Even with GA status, developers should keep the Git workspace clean, isolate complex tasks on separate branches, avoid exposing production credentials, and treat the debugger‑enabled AI as a collaborative assistant rather than an autonomous programmer.

IntelliJ IDEA as an AI Workbench

IntelliJ IDEA is evolving from a pure code editor to a platform where AI agents retrieve project context, execute tasks, and present results. Developers will likely start their day by checking the status of various AI‑driven agents (e.g., upgrading Spring Boot, debugging failing tests, reviewing PRs) and then intervene to approve plans, answer questions, and validate outcomes.

The key takeaway is that AI’s ability to use the debugger, plan tasks, and interact with databases marks a transition from code generation to genuine engineering collaboration.