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.

DB-first Meets Code-first: Persistence Workflows in IntelliJ IDEA

IntelliJ IDEA supports both directions teams work with persistence—starting from an existing schema or starting from code—but much of this tooling flies under the radar.
In this session, I'll run hands-on IDE demos covering DB-first and code-first workflows for both JPA and Spring Data JDBC.

What you'll see:

* DB-first: connect to a schema, scaffold entities, and iterate without destructive regeneration
* Code-first: evolve the model, preview database impact, and produce migration scripts with Flyway or Liquibase
* JPA vs Spring Data JDBC: where modeling choices and IDE assistance differ between the two

Who this is for:

Developers working with relational databases in Kotlin or Java who want a repeatable workflow for keeping code and schema in sync, in either direction.

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.

The Ultimate Showdown of Database Migration Tools

When it comes to database migration in the Spring ecosystem, two heavyweights dominate: Liquibase and Flyway. While both tools bring unique strengths to the table, only one can claim victory in this exciting technical showdown.

* Which languages support migrations, and how do the costs compare?
* What features do the rollbacks offer?
* What versioning schemes and strategies do they utilize?
* How do their runtimes operate?

No stone left unturned! Which migration tool will reign supreme in your Spring project? Join us to learn the differences between tools and cast your vote to make the ultimate decision!

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

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