What’s New in IntelliJ IDEA 2025.3

IntelliJ IDEA's new multi-agent experience adds even more flexibility and power to your development workflow. Now, multiple agents are available from the same chat interface, allowing you to switch between them seamlessly and get the right kind of assistance for every task. Alongside Junie, we have natively integrated the first third-party AI agent – Claude Agent.

Monitoring and managing your AI resources just got a lot easier, as you can now view your remaining AI Credits, renewal date, and top-up balance directly inside IntelliJ IDEA.

Forget about shortcuts and use code native patterns to harness the power of your favorite IDE!

To help keep you in the flow, IntelliJ IDEA 2025.3 introduces command completion – a new way to access context-aware actions directly from code completion.

• Type . to see code completion and postfix completion suggestions, as well as actions.
• Type .. to filter the results to actions only.
• Select an action to see the exact context and preview what the action will do if applied.

This refinement makes development more comfortable and efficient, as you no longer need to decide between multiple ways to find and invoke actions in a given situation.

For details, check out the blog post.

Don't lose time distracted with version configuration. Simply add a version to your request-mapping annotations and choose a strategy – path, header, or media type. That's it!

IntelliJ IDEA makes the versioning process even smoother by validating version formats, flagging ambiguous or misconfigured endpoints, and generating the necessary configuration. Additionally, HTTP request generation and navigation between client and server also respect versions, keeping everything in sync.

When your app needs to call another REST service – a daily task – you can now create the client with almost no setup.

Since Spring Framework 6, it's been possible to define a plain Java interface and mark its methods with HTTP annotations, but you still had to configure the underlying client implementation. In Spring Framework 7, the process is even simpler. Just add an interface and a few annotations, and you're good to go – no factories and no customizer beans.

IntelliJ IDEA builds on this streamlined process. It warns you if a client interface isn't configured properly, helps you use client interfaces in code, and supports navigation and HTTP request generation.

Spring Framework 7 makes registering a bean as simple as implementing BeanRegistrar with a concise DSL. IntelliJ IDEA's advanced code analysis now understands even Spring 7's dynamically registered beans. Additionally, the IDE marks registered classes with the Spring bean gutter icon, lets you navigate to where the bean is registered, and runs inspections to catch registration issues early.

With the Kotlin DSL, you can group related beans together, register them conditionally, or reuse registration logic just like any other Kotlin function, keeping configuration modular and maintainable. Combined with the routing DSL's flexibility for defining APIs with conditions, loops, and nesting, Spring applications gain a unified, Kotlin-native style that is both expressive and efficient.

As Spring Data JDBC is gaining popularity, IntelliJ IDEA brings first-class support on par with its support for Spring Data JPA, enabling you to:

• Generate entity classes from existing database tables, including those with composite keys.
• Generate DDL from your @Table classes and enjoy support for Liquibase and Flyway.
• Compare your code model with the database and create scripts to align them.
• Create Spring Data repositories on the fly and wire them into your code instantly.
• Get smart completion for Spring Data repository-derived query methods.
• Add table columns directly into your entity classes via completion.

Recently, the Spring Data team announced AOT code generation for Spring Data repositories, which improves performance and makes debugging easier. This is particularly useful for debugging derived query methods, which used to be challenging because they were generated from method names on the fly. With AOT, you can see the queries that will run before execution, and execution itself is faster because code is already generated.

IntelliJ IDEA 2025.3 enhances this improvement by detecting generated implementations for Spring Data repositories and showing the queries right in your code. The IDE lets you navigate to the query execution code so you can set a breakpoint and trace the flow. You can also execute generated queries directly in the IDE without running the application.

The Spring Debugger plugin now has over 250,000 users, and your feedback has allowed us to continue improving it to help you better understand what's happening inside your Spring applications. Right after the plugin's release, the top question was "Can I debug remote applications?" We're now happy to say that the answer is: "Absolutely!"

Simply start your app with a debug port open, and then attach from the IDE. That's it – you're all set.

We've also added another highly anticipated feature: IntelliJ IDEA can now automatically connect to your database when the application starts.

Make sure to update your Spring Debugger plugin to the latest version to get these improvements and other fixes.

Deploying databases and services just got easier, as you can write, apply, and manage everything directly in your editor.

Stay in context with the cluster and namespace selector at the top, and spot issues fast with live resource status icons. Struggling with missing env variables or failed pods? Fix them instantly with one-click logs and redeploy without leaving your manifest.

Secure your service setup with in-editor secret management. View and copy database credentials directly from your YAML.

Need to connect? Use one-click port forwarding to forward container ports, autoload secrets, and set up an instant connection to your database or service in seconds.

From deployment to debugging to connecting, everything is seamless and in one place – helping you stay focused and work smarter!

Released in September 2025, Java 25 is the next Long-Term Support (LTS) version of the Java platform. IntelliJ IDEA has supported Java 25 from day one of its release, ensuring developers could immediately benefit from the latest language, runtime, and tooling enhancements.

In this release, we are adding the finishing touches to this support – making sure all bundled tools and libraries, including Async Profiler 4.1 and JaCoCo, are compatible with Java 25 runtimes.

JDK 25 builds from all major vendors – Oracle OpenJDK, IBM Semeru J9, GraalVM, and Microsoft Build of OpenJDK – are available for download directly from IntelliJ IDEA.

For details about the features and improvements introduced between Java 21 and Java 25, check out this detailed blog post.

The Develocity IntelliJ plugin brings profiling into the build process. With it, you can view detailed build characteristics directly in IntelliJ IDEA, identify performance bottlenecks, and observe how build changes affect speed and resource utilization. No modifications to build scripts are required – simply enable the corresponding setting in the plugin.

For example, you can easily detect a task that isn't using the build cache and runs unnecessarily—something that might be hard to notice in logs but becomes immediately clear in visual charts.

The plugin was developed as a joint effort between JetBrains and Gradle Enterprise engineers, resulting in a seamless integration that fits naturally into the IntelliJ IDEA UI and doesn't require any change to your existing workflow.

Currently, the plugin supports both Gradle and Maven builds. You can find more details in this blog post.

The Islands theme is now the default look in IntelliJ IDEA. More than just a visual refresh, it reflects our commitment to providing the ultimate comfort throughout your development experience.

Instantly recognizable tabs, improved in-editor contrast, clear separation between working areas, and rounded corners create a soft and balanced environment that was designed around one goal: helping you stay focused and code with ease.

Learn more in this blog post.