IntelliJ IDEA
Conf 2026

Tired of treating AI like a black-box REST endpoint? What if you could own the stack – shape the tensors, steer memory, and pick execution providers?

In this session, we make that shift. Today, with JDK 25, you can wire real models – LLMs, image classifiers, or object detection algorithms – straight from Java via the Foreign Function and Memory API to call native runtimes like ONNX for fast CPU/GPU inference. You will learn how to map tensor buffers to Java MemorySegment and flip execution providers, all from the comfort of a Java application. Then you will push further with Project Babylon’s Code Reflection, expressing model logic as Java code that Babylon can analyze and lower to accelerator backends, skipping external model files or the need for a glue language.

Build expressive and testable FFM-based inference today and author pure Java AI-ready models with Code Reflection tomorrow!

AI coding agents are powerful, but they often feel unpredictable. Without structure, they can jump into implementation, miss requirements, or generate code you can’t easily track. Spec-driven development is a practical approach that brings order to this process.

The method is simple: start with clear, high-level requirements, refine them into a detailed development plan, then break that plan into a task list with trackable steps. The AI agent works from these artifacts – requirements.md, plan.md, and tasks.md – instead of ad-hoc prompts. Each step becomes explicit, reviewable, and repeatable.

In this talk, I’ll show how to apply spec-driven development and explain my intuition for this approach. We’ll walk through an example, documenting requirements, generating a plan, creating tasks, and guiding the AI through execution one step at a time. Along the way, you’ll see techniques for controlling workflows, reviewing changes, and avoiding “black-box” code generation.

If you’ve tried coding with AI tools but found them chaotic, this session will give you a framework to make them reliable partners.

AI coding agents have reached a point where they can meaningfully participate in real software development workflows, particularly in large and complex Java codebases, handling tasks such as issue classification, pull request merging, and increasing test coverage. In this talk, Mark shares his practical experience automating these workflows using autonomous agents, based on work carried out in real repositories and integrated into everyday development practice.

This talk gives you an introduction to Spring AI Agents and Spring AI Bench, two complementary projects from the Spring AI Community. Spring AI Agents provides a portable abstraction for running CLI-based coding agents – shifting from using Spring AI's ChatClient for chat completions to using AgentClient for achieving goals. AgentClient wraps any agent CLI through a single interface, using explicit goals, tools, context, and a built-in judge framework to trust but verify agent behavior. Combined with the Agent Context Protocol (ACP), this establishes a consistent client and wire-level integration model across tools and environments. Spring AI Bench applies the same framework to evaluate how effectively agents complete concrete, goal-directed development tasks.

Finally, Mark reflects briefly on what it means to develop these systems in an AI-first manner. Spring AI Agents and Spring AI Bench were themselves built with significant assistance from coding agents, offering practical insight into how agents behave as collaborators rather than tools, and where clear structure, evaluation, and feedback loops become essential to making agent-driven development reliable and repeatable.

Are you tired of watching Maven builds crawl at a snail's pace, wasting precious development time? Spending too much time at the coffee machine, or having wooden sword fights, with the excuse "my code is compiling"?

Join me to learn how to supercharge your Maven builds! We’ll cover three main steps to start speeding up your project build and learn how each speeds up your build, when they provide the biggest gains, and what pitfalls await.

Take the next step in boosting your developer productivity by learning practical tips to decrease context switching and increase development speed and the feedback cycle. Your journey from a snail's pace to rocket speed begins today!

Agentic AI coding assistants offer powerful capabilities, but they also introduce significant security risks. Granting them unsupervised access is not a viable option, yet overly restricting them stifles their potential. This session addresses this critical dilemma by proposing a new security primitive: Docker sandboxes.

We will explore a practical framework for encapsulating AI agents within containerized, isolated worlds. Learn how this approach provides a known security profile, an intuitive setup, and a reliable boundary. We'll discuss the design principles needed to safely embrace the "infinite monkey" nature of AI assistants, ensuring that while they are free to work, any potential havoc remains localized and controlled.

This session will demonstrate how GraalVM enables multiple programming languages to run and interoperate within a single, secure, and high-performance runtime. It will highlight practical use cases such as adding flexible scripting to JVM-based applications, safely executing AI-generated code in a sandboxed environment, and building unified data-processing pipelines that combine the strengths of both the Python and JVM ecosystems in one application. The session will also show how IntelliJ IDEA’s enhanced polyglot tooling streamlines development, debugging, and navigation across mixed-language projects.

Software developers don’t just write code. As users, contributors, and community leaders, they help shape the tools and ecosystems they rely on every day. In this panel, software community leaders from JetBrains, SAS, AWS, Neo4J, the Apache Software Foundation, and the United Nations Office of Information and Communications Technology discuss how developer communities influence everything from enterprise platforms and IDEs to public-sector technology. We’ll explore how developer communities, education, conferences, and contributions drive product decisions, what healthy collaboration looks like at scale, and how individual developers can have a significant impact.

Over the last 30 years, Java has been the preferred technology for developing enterprise applications. Frameworks and approaches such as J2EE, Spring Framework, Java EE, Spring Boot, and Jakarta EE all contribute to this success story.

Jakarta EE 11 has features for increasing performance and developer productivity, such as support for virtual threads and the new Jakarta Data specification.

This session will give you a history lesson on Enterprise Java and an overview of everything new in Jakarta EE 11, alongside lots of code demos. We will also look ahead and see what's in the pipeline for Jakarta EE 12.

Have you ever wanted to play around with a dataset, but the thought of setting up a Python development environment seemed like too much of a hassle?

Meet Kotlin Notebook – a plugin for IntelliJ IDEA.

In my work, I sit firmly in the Kotlin/JVM ecosystem. And I like it here. But recently, I found myself with a dataset and some questions. I wanted to inspect the data and get some answers as quickly as possible. Kotlin Notebook turned out to be the perfect tool for that.

In this talk, I will share with you how easy it is to get from data science noob to data wrangling badass, using the tools you are already familiar with.

We will cover:

• Data science basics
• Connecting your Kotlin Notebook to an existing Postgres database
• Accessing and manipulating the data with Kotlin DataFrame
• Plotting your findings with the Kandy Library

You will leave this talk with the knowledge and confidence to inspect a dataset, form a research question, collect the data, and plot the result, without ever leaving the comfort of your IDE.

AI is accelerating code and test creation, leading to larger changes and rapidly expanding codebases. This growth, however, intensifies the complexities of troubleshooting.

To keep up with AI, we need faster feedback cycles, as well as actionable insights. Inspired by DORA, we measure this with Developer-local or CI-local Time To Restore (TTR), for a failing local or CI build, respectively.

Only AI-powered troubleshooting can help streamline AI-powered development, and what better place to observe and troubleshoot builds and tests than inside your IDE, like IntelliJ IDEA or Android Studio?

In this presentation, we'll explore the use of the free Develocity IntelliJ plugin and Develocity’s AI features for rapidly troubleshooting failures and performance issues within the comfort of your IDE.

Nobody's talking about this: MCP isn't just another way to build chatbots. It's the bridge we've been missing between AI reasoning and real-time data systems.

Teams build AI applications that work great in demos but fall apart with production data. Your agents analyze historical reports but can't tell what's happening in your Kafka streams. They're blind to schema changes and disconnected from events that matter to your business.

Instead of treating streaming platforms like black boxes, you expose them directly to your agents via MCP protocol. Suddenly, your AI doesn't just read about data – it lives inside your data flows.

Learn what becomes possible when you stop thinking about AI as an external service and start treating it as part of your streaming architecture. We'll build systems where agents subscribe to real-time events, reason about evolving schemas, and make decisions that ripple through your data platform.

When you master your tools, they stop being “just an IDE and a framework” and start working like extra hands on your project. Spring Boot streamlines application development, while IntelliJ IDEA takes that productivity and amplifies it with inspections, navigation, refactorings, and Spring-aware debugging.

In this session, Spring Developer Advocate Josh Long will walk you through real-world workflows that show how these tools work together – from project setup and configuration to troubleshooting tricky runtime issues.

You’ll leave with practical tips you can apply immediately to ship features faster and with more confidence.