Debugging with IntelliJ IDEA

Historically, debuggers are used to help locate and fix bugs. Nowadays, the debugger in IntelliJ IDEA can help you do much more than that. Let's see how the debugger helps make the development process more productive. I demo various features for debugging Java applications, including not-so-standard ones, like:

* Lambda breakpoints
* Stream chain tracing
* Dropping the frame
* Emulated method breakpoint
* Evaluate and log
* Non-suspending breakpoints
* Custom data renderers and more

100% live coding session

"Sudo, Make Me a Sandwich!" - Live coding with AI tools

AI-assisted coding promises to boost developer productivity, but how much can we actually rely on these tools? In this live coding session, we’ll put AI-powered development assistants to the test—experimenting with code completion, chat conversations with LLMs, agentic workflows, and other techniques inside IntelliJ IDEA.

Through real-world trial and error, we’ll see what these tools can (and can’t) do, explore their strengths and quirks, and discuss how developers can stay in control while leveraging AI in their workflows. Expect surprises, insights, and maybe even a sandwich—if the AI can figure it out!

A fun live coding session, oriented on developer meetups

Building AI Agents in Kotlin

In this session, we’ll walk step-by-step through the process of building AI agents in Kotlin using Koog — a lightweight framework for constructing tool-using LLM agents. Starting from first principles, we’ll examine how an agent interacts with a language model, how tools are registered and invoked, and how to structure reliable interactions whether you're working with local models or remote APIs from OpenAI and Google.

Along the way, we’ll explore integrations with Model Control Protocol (MCP) and demonstrate how they enable structured coordination between components. Using Koog's DSL, we'll describe agent workflows as graphs, making the logic of the agent both readable and reproducible.

The session will culminate in building a simple coding agent — capable of generating and testing small programs — showing how to integrate tools like test runners, linters, and file systems into a coherent agent behavior.

Koog is the result of our internal efforts at JetBrains to build a practical, Kotlin-native agent framework, and is already at the core of the coding agent inside the AI Assistant plugin. This talk will be useful for engineers interested in understanding and building LLM-based automation, from scratch to working prototypes, with full control over the process.

Data Analysis with Kotlin Notebook

Notebooks are an environment where you can write and execute code fragments and create beautiful interactive tables displaying hierarchical data, which makes it a good place for prototyping and trying out ideas.

This talk offers a glimpse into the practical applications of Kotlin Notebook for data analytics and is suitable for developers of all levels.

I will show you how to use Kotlin Notebook for data analysis, demonstrating how it parses and visualizes complex data, briefly touching on the Dataframe and Kandy libraries, and showcasing how you can improve different aspects of software development.

Things you will learn in this presentation:
* How to configure and use Kotlin Notebook plugin in IntelliJ IDEA
* How to use the Kotlin Dataframe library for transforming the data
* How to create nice-looking graphs in notebooks with Kandy

Harnessing the Power of AI in IntelliJ IDEA

AI-powered tools are transforming software development, but how much control do they give developers over their workflow?

In this session, we’ll explore how AI assistance in IntelliJ IDEA—through both JetBrains AI Assistant and the new Junie coding agent—supports developers in writing, understanding, and improving code.

I will demonstrate the capabilities of the AI-assisted coding in IntelliJ IDEA by exercising the prompts for various development workflows: explore legacy code, improve existing code via refactoring and tests, learn new technology, or implement new functionality in your application.

Is it a productivity booster or a placebo? I will do my best to explain in this session.

IntelliJ IDEA Tips & Tricks

IntelliJ IDEA is packed with useful features that enhance developer productivity and simplify working with code. This session will take you through the cool features of IntelliJ IDEA: refactorings, shortcuts, fast navigation, a variety of code completion options, live templates, configuration options, language injection, the debugger (which is a gem on its own), and other productivity features that the IDE provides.

We will also look at the latest additions to IntelliJ IDEA, such as improvements for Spring and JPA support and, of course, the AI assistant, which brings advancements in Machine Learning closer to developer tooling.

The talk includes the new features coming from the IntelliJ IDEA engineering team

Spring Debugger

Spring is known for its flexibility and power—but also for the invisible wiring that can make understanding what’s really happening in your application tricky. Beans appear as if by magic, properties seem to resolve themselves, and sometimes it’s hard to see how everything fits together.

In this session, we’ll peel back the layers of Spring’s runtime behavior and learn how to debug Spring applications with precision. We’ll explore how to trace bean creation and injection, follow property resolution across profiles and configuration sources, and inspect transactions and data connections—all while keeping your mental model of the application crystal clear.

We’ll use the Spring Debugger in IntelliJ IDEA to make these insights visible, giving you the ability to explore the framework’s internals interactively instead of guessing or grepping through logs.

You’ll learn how to:

* Understand how Spring resolves configuration and property values.
* See which beans are created, injected, and why specific candidates are chosen.
* Track transactions, data sources, and runtime context in real time.
* Turn Spring’s dynamic behavior into something you can explore, reason about, and explain.

By the end, you’ll not only feel more confident navigating Spring Boot’s inner workings—you’ll see how debugging can become a tool for learning and mastery, not just fixing what’s broken.

Spec-Driven Development with AI Agents: From High-Level Requirements to Working Software

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 workflow, 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.