Registration & breakfast

---

Breakfast

---

Break

The best time to take coffee or juice

---

Coffee Break

The best time to talk with speakers and attendees

---

Lunch Break

---

Keynote

---

Opening ceremony

---

Closing ceremony

---

TBA

To Be Announced

---

Lightning talk

---

---

Topic tables

Join other attendees and share ideas, talk about the recent challenges, or find solution for a problem. During this session you can connect with other like-minded people in a space designated for certain languages, technologies, and interests.
1. Suggest a topic
Look for large white sheets of paper, and tell everyone what is on your mind! You can also tweet using #topicforgeecon hashtag. Vote for topics (mark it with line/x/heart) and like tweets to show others you’re interested.
2. Choose a room and have fun
We will group similar topics and assign a room. Topics will be pinned before room entrance (list of topics and rooms will be also posted using attendees slack channel - slack.geecon.cz), so you will be able to join others also interested in eg. Kotlin, JVM tuning, Machine learning or testability.

---

Open Spaces + Part @HEVRE, Beera Meiselsa 18 Street

---

Discussion panel 4

Session type: PANEL

---

Party

Party time!

---

Lunch - room 5

Grilled chicken in paprika salsa + rice with veggies + salad

---

Lunch - room 3

Tender pork loin in green pepper sauce + boiled potatoes + salad

---

Lunch - room 2

Primavera pasta + salad (VEGE)

---

Lunch - room 5

Turkey in creamy-thyme sauce + rice + salad

---

Lunch - room 3

Fish with roasted potatoes + salad

---

Lunch - room 2

Russian dumplings and spinach + salad (VEGE)

---

Lunch - room 7

L3_1

---

Lunch - room 5

L3_2

---

Lunch - room 3

L3_3

---

Dehumanizing Agents: Why Explainability is Crucial in the LLM Era

Session type: AI

Human beings are biased and often wrong. Artificial intelligence learns from human-created data. Therefore, artificial intelligence is biased and often wrong. This has been a critical problem across machine learning applications in the last years. To break open the black box of AI models, and understand how they make decisions, the concept of explainability was introduced. Then, LLMs entered the chat. They answer our questions confidently and with a beautiful prose, even when they are making up data. Explainability then becomes essential to trust -or not- their output. But when the existing explainable AI methods cannot be directly applied to these models, what do we do? In this talk, we will delve into the topic of explainable AI, and its importance in the current context of LLMs and agents. Starting from traditional machine learning to then focus on generative AI, we will cover the different methods that can be implemented, from well-known ones to novel proposals stemming from our internal research. We will go through the main risks and challenges we have encountered when implementing explainability, and how we have solved them. Finally, we will share some tips and tricks to integrate explanations into LLM-based workflows (also when using existing third-party services that are not natively explainable).

---

AI vs. Karen: Building Real-Time Sentiment Analysis Pipelines at Scale

Session type: AI

We’ve all heard that “the customer is always right'. But let’s be honest, some customers are just impossible to please. What if we could detect them before they turn into ALL-CAPS review bombers, in real-time? In this talk, we’ll walk through how to build AI-powered streaming pipelines using Apache Kafka and Apache Flink that can detect frustrated users and respond in real time at massive scale. We’ll explore how to embed AI models directly into data streams for live inference, discuss the trade-offs between using Large Language Models (LLMs) and Small Language Models (SLMs), and tackle the real-world challenges of latency, scale, and cost optimization in streaming AI architectures. Finally, we’ll demo a live end-to-end example, from data ingestion to AI scoring and visualization, that you can later run on your own setup. Whether you’re experienced in streaming systems or just curious about applying AI to real-world problems, this session will leave you with the needed practical foundation, insights, inspiration, and hopefully a few laughs along the way.

---

Agents With Seatbelts: Practical Ways to Keep AI Code Gen Under Control

Session type: AI

In this session I will share **best practices** for using MCP setups and AI **Agents** in real development workflows 🤖. The goal is to improve both **quality** and **security**, since even with all the excitement around these tools, it’s still very easy to create confusing interactions, accidental data exposure, or Agents that trigger actions we never intended. I will also present **reports comparing how different LLM models generate code**, showing clear differences in stability, output consistency, and the amount of guidance each model needs to avoid mistakes. Along with that, I’ll bring recent **figures showing the surprisingly low productivity gains** many teams report when adopting AI tools—often just small improvements instead of the big jumps everyone expects. We will look at why this happens: unclear prompts, weak tool design, loose permissions, and wrong assumptions about what the models can really handle. The talk focuses on practical habits that developers can apply right away: tightening tool access, simplifying and focusing context, adding lightweight validation steps, and using safety patterns that prevent the common failures. My goal is to help teams build **more reliable, productive, and secure AI workflows**, making AI code generation a real benefit rather than a risky experiment 😅.

---

The Enemy Within: How AI is Weaponizing Your Code

Session type: SECURITY

Here are no black cats, broken mirrors or sudden storms to announce the news. Still, AI-generated code has become a double-edged sword, offering unparalleled productivity while quietly introducing vulnerabilities and weaknesses. Whether through poisoned models, maliciously crafted to inject flaws or poor-quality training data, your trusted AI companion could be a Trojan horse. This talk unveils the dark side of AI in software development, exposing how attackers exploit AI to compromise open-source projects and infiltrate the software supply chain. Learn how bad actors leverage sophisticated techniques to embed security flaws in libraries you trust, and discover how untested, AI-generated solutions can open doors to catastrophic exploits. With real-world examples, We'll dissect how these attacks happen and offer strategies to safeguard your projects. In the battle for secure software, your tools could be your greatest weakness or your first line of defence. Prepare to confront the chilling truth about AI and your code.

---

Concurrency testing on the JVM

Session type: TESTING

When testing a concurrent program, you never know if it really works or if you got lucky. As the famous Dijkstra quote says: 'Program testing can be used to show the presence of bugs, but never to show their absence!'. Full model checking or formal correctness proofs remain largely intractable: too expensive, too slow to develop (even with AI assistance), and too hard to maintain over time. However, not all hope is lost: a growing body of tools is available to help you gain more confidence with your concurrent programs. These tools work by instrumenting the bytecode and executing a series of thread interleavings deterministically. It's not a correctness proof, but it might boost your confidence just enough to ship the code. In the talk, I'd like to present two such tools: Lincheck and Fray, compare their functionalities, demonstrate how they work, identify the kinds of problems they might detect, discuss their applications, and highlight the issues they have already helped uncover.

---

`Gemini Plays Final Fantasy`: Teaching LLMs to play jRPG from scratch

Session type: AI

It’s 2025, and AI demos still look exactly the same: a TODO app, a chatbot with RAG, “watch me vibe code.” I’m bored of it - and I’m guessing you are too. So instead, we take an (my own!) NES emulator written in Kotlin, boot up Final Fantasy I, and see whether an LLM can defeat even a single goblin. Along the way, we’ll unpack what “AI beat a game” actually means, why an emulator is such an interesting playground for agents, how a model “sees” the world through memory dumps and symbols, and where everything starts to break down: latency, hallucinations, context limits. Will we win? It doesn’t matter - even failure will teach us more about AI systems than the hundredth slide about prompt engineering 😊

---

An Opinionated Guide to Bulletproof APIs with Java

Session type: ARCHITECTURE

Writing a 'Hello World' endpoint is easy. But building an API that is secure, observable, and capable of evolving without breaking every client? That’s where the real engineering happens. We often pollute our business logic with validation, security checks, and boilerplate, creating a maintenance nightmare. It’s time to clean up our act. In this session, we’ll move beyond basic CRUD to explore 5 essential patterns for building production-grade APIs. We will combine standard Jakarta EE/MicroProfile features with powerful custom implementations to tackle the cross-cutting concerns that matter most.

---

Scotty, I need Warp Speed - Ways to improve the JVM startup/warmup

Session type: PERFORMANCE

When running Java at scale, the JVM startup time can become a limitation. Especially when you look at spinning up new instances of an app as response to changes in load, the warmup time can be a problem. A couple of years ago you only had CDS that could help you with the startup but meanwhile there are a couple of solutions that can help you to let you JVM start super fast. These days we have CRaC, Native Image, Leyden, InstantOn, Ready Now, JIT as a Service and Cloud Native Compiler, which are all solutions that help to reduce the startup time of a JVM. Each of those is not a Silver Bullet, so you have to choose the right solution for your problem. This session will give you a short overview of the different solutions to increase your JVM startup performance and will try to give you some hints on how to choose the right solution for your application.

---

Business won't wait, the platform won't either. How the infra team becomes a partner in delivering business value and what should change for that to be possible

Session type: DEVOPS

Business does not wait for infrastructure, and platforms that cannot keep up quickly become bottlenecks. Many teams adopt microservices expecting speed, only to end up with more complexity, duplication, and frustrated engineers. Using a real-world case study from Expedia, this talk shows why IT is often seen as a slow cost center and how the lack of automation, standards, and ownership increases cognitive load. I introduce platform teams as a way to turn infrastructure into an internal product that enables teams through self-service, automation, and clear standards. If you already have microservices but delivery still feels slow and risky, this talk explains why a platform is essential to scale, align technology with business goals, and deliver value faster and more reliably.

---

What is multimodal RAG, and can we build a village with it?

Session type: AI

Multimodal Retrieval-Augmented Generation (RAG) is the art of using your own textual, visual and audio data to enhance prompts before they’re processed by a generative AI. Imagine users asking a question, the system querying your own data pool for answers, and then using generative AI to craft a coherent, relevant response… which is perfect for non-player characters (NPCs)! These are characters in video games that are not controlled by the player. Typically, NPCs have static and hardcoded responses, but with this approach we could make them more lifelike and fun to interact with! We can take it even further. Imagine NPCs interacting with each other, having goals, and moving around dynamically, all driven by complex RAG workflows. This idea is exactly what Alexander has explored and wants to share with you! Whether you’re a seasoned backend engineer or an adventurous developer seeking fresh ideas, Alexander will guide you through setting up basic to advanced RAG workflows. He'll demonstrate the challenges and benefits of using tools like Langchain4j to create RAG systems that provide up to date and factual answers. Alexander’s goal is to offer an engaging and fun look at RAG, inspiring you to dive in and explore its potential yourself. Get ready for a session that mixes education and absurd fun to discover the inner workings of multimodal RAG!

---

Building Self-Correcting AI Agents: Iterative Refinement Patterns with Spring AI

Session type: AI

At their core, AI agents are context orchestrators - continuously gathering information, querying models, evaluating outputs, and adapting their approach. This presentation examines how Spring AI's Advisor architecture enables sophisticated self-improving agent behaviors. Advisors act as middleware (an AI harness) in the AI interaction pipeline, allowing developers to inject capabilities like Memory and RAG as composable building blocks. However, real-world agent workflows require more than linear, prescriptive processing: they need iterative tool invocation, validation with automatic retry logic, and quality assessment through continuous evaluation. This talk introduces Recursive Advisors as a mechanism for controlled iteration within the advisor pipeline. Through hands-on demonstrations using Spring AI's ChatClient API, practical examples will be presented to learn what it takes to build your own MemGPT or ClaudeCode-like agentic systems. Attendees will discover how to construct agents that progressively refine their execution strategies—leveraging self-assessment and feedback loops to achieve higher quality outcomes through autonomous improvement.

---

Learning modern Java the playful way

Session type: NEWS

Staying up to date with Modern Java can feel overwhelming. If you don’t have any experience with recent Java versions (or at all), features like Structured Concurrency or Stream Gatherers might sound exciting, but also scary: “How do I even get started with that?” Fear not! In this session Marit and Piotr will explain to you the new exciting things and also show you how to use them in your IDE, so that the next day you can start having fun and profit with modern Java in your favorite tools on your own.

---

Teaching an Old Pet Clinic New Tricks: Introducing Agents into Existing Applications

Session type: AI

While most talks about AI agents focus on greenfield projects, most Spring developers work on existing applications, with established domain models, services, and architectural constraints. In this session, we will show how the Embabel Agent Framework is designed specifically for that reality. Starting from the classic Spring Petclinic, we will gradually introduce agent functionality without rewriting the application. We will extend Petclinic with agents that can plan veterinary visits, reason about pet health data, and provide contextual recommendations to pet owners. These agents integrate directly with existing Spring services, repositories, and domain objects, demonstrating how agentic behavior can complement, rather than replace, traditional Spring architecture. The talk focuses on incremental adoption: where agents fit into a mature codebase, how they interact with deterministic business logic, and how to keep agent behavior in check. This session is aimed at Spring developers who want to introduce agentic systems pragmatically, using familiar tools and patterns.

---

The 50x Developer: Java's Unfair Advantage in the Age of AI Agents

Session type: AI

AI coding agents generate code faster than any developer can type. But speed without structure produces disposable code. Java's public specifications and the Java Community Process give LLMs something most ecosystems lack: normative APIs, consistent patterns, and 25 years of documented conventions. In this session, we build a Java application from scratch using AI agents and live prompts. Every line of generated code follows established architectural patterns, uses standard annotations, and produces no hallucinations. The result: code that is equally readable by humans and machines. Expect live coding, real prompts, and real mistakes. Questions and discussion during the session are not just welcome - they shape where the code goes next.

---

Of Microservices and Monoliths, and Everything in Between

Session type: ARCHITECTURE

Deciding between microservices, monoliths, or a hybrid architecture? We’ll explore the characteristics of each and how different architectural styles support various technical, organizational, and operational goals. Most organizations don’t choose just one path—architectures evolve, and combinations often coexist. The Spring portfolio offers powerful support across this spectrum. We’ll go through an example of the evolution of an application, showing how the Spring portfolio supports structure within a modular monolith and enables a smooth transition to microservices. Whether you’re scaling a small team or managing a complex system, this session will equip you to make thoughtful, needs-driven architectural decisions.

---

Modules: design around processes, not data

Session type: ARCHITECTURE

Most devs have a data-centric perspective on modularity: they design a system around nouns and data. That is due to 3rd and 5th normal form in relational databases which they still teach you at a University. But here’s the kicker - it’s wrong. We use a higher level language because we implement complex business processes. If we wanted to focus on data, we would be using SQL. In this talk I’ll give you a set of rules for a module that helps me design enterprise software that is easy to work with, test, change and performs really well. I’ll also show you when it’s safe to break those rules. The goal is to make your apps “infinitely scalable”, or rather: for the system to never slow you down as it grows.

---

Troubleshooting Production with AI: Automating Tribal Knowledge @ Scale

Session type: AI

Production environments have always been noisy and stressful, flooding engineers with alerts, logs, and dashboards. On-call engineers are expected to connect the dots under pressure, relying on undocumented tribal knowledge and hard-won experience. And with AI accelerating coding, we’re now pushing more code into production faster than ever, making these environments even noisier and more demanding. AI sounds like the obvious solution for production as well, right? But here’s the truth: it’s not magic. Out of the box, no AI understands the complexity and context of your environment. The real value comes when you capture and structure tribal knowledge into context-aware guides, where AI can truly shine in automating and accelerating troubleshooting. In this talk, we’ll share our Wix–Wildmoose journey: how we started by mapping domain expertise into conceptual troubleshooting playbooks, then automated them with Wildmoose (an AI-based production troubleshooting product), and iteratively tuned the system through engineer–AI collaboration. The result? an AI-powered troubleshooting flow that acts on our unique production signals, achieving 80% accuracy! reducing MTTR, and significantly lightened the on-call burden. You’ll hear practical lessons learned, what worked, what didn’t, and how you can strike the right balance between AI automation and human judgment.

---

10 Billion Records vs. The Regulator: An Architectural Post-Mortem

Session type: ARCHITECTURE

What happens when your architecture doesn't just fail a performance test, but triggers a national regulatory investigation? In this session, we go inside a critical system failure at a major bank that led to a formal report to BaFin and a complete rethink of our data strategy. Dealing with 11TB of data on Oracle Exadata taught us that at a certain scale—specifically, the 10-billion-record mark—standard indexing strategies and read-side duplicate checks don't just slow down; they collapse. We will walk through the 'War Room' decisions that led us to flip our architecture on its head, moving from ineffective read-side validation to a high-performance write-side integrity strategy. Key takeaways include:

• The Compliance-Performance Paradox: How to navigate technical decisions when a 'bank crash' brings regulators to your door.
• Architectural Pivots: The logic and implementation details of moving validation to the write-side to stabilize massive ingestion pipelines.
• The Great Exit: How we are building a 'Zero-Loss' migration strategy to move 10 billion records from legacy Exadata to Cloud PostgreSQL, including the business case that made it possible.

---

The Past, Present, and Future of Enterprise Java

Session type: NEWS

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. The Jakarta EE 11, with 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 of Enterprise Java as well as an overview of everything brought to you by Jakarta EE 11 with lots of code demos. We will also look forward and check out what's in the pipeline for Jakarta EE 12 and how enterprises can cope with the ever increasing presence of AI.

---

What’s All the Fuss About Quantum Computing?

Session type: NEWS

Quantum computing has been moving from academic papers to mainstream headlines—but what is it really, and why should we care? If you’ve never heard about quantum computing, this talk is your starting point. I will begin with the fundamentals: what “quantum” actually means, how quantum computers differ from classical ones, and which kinds of problems they aim to solve. Without diving deep into physics or math, I will build an intuitive understanding of the core ideas. Next, I will explore why quantum computing matters today—where its real potential lies, which industries are paying attention, and which use cases are realistic in the near future. A special focus will be placed on security. I will explain why quantum computing is particularly relevant for anyone working with cryptography, secure communication, and data protection: which widely used cryptographic algorithms are vulnerable to quantum attacks, what “post-quantum cryptography” really means, and why the impact matters even before large-scale quantum computers exist. Finally, I will separate expectations from reality, cutting through the hype to discuss what quantum computing can (and cannot) deliver, what risks are real today, and what timelines we should realistically expect. Whether you’re a developer, architect, security professional, or simply curious about emerging technologies, this session will help you understand why quantum computing is worth listening to—now and in the years ahead.

---

Unlocking Java’s Code Maze: Live Puzzles for the Curious Developer

Session type: NEWS

Step into Java’s Code Maze - a live, puzzle-driven session where real Java snippets turn into challenges waiting to be cracked. Together with Mihaela, explore coding exercises that expose surprising behaviors, performance traps, and optimization opportunities across modern Java features, from virtual threads to streams and beyond. Expect a dynamic quiz format, audience participation, and plenty of 'oh, that’s why!' moments. Walk away not only with sharper instincts, but with a deeper understanding of how to write cleaner, faster, and more expressive Java code.

---

Before the To-Do List: The One Conversation Every Team Needs

Session type: TEAMCULTURE

It starts innocently enough. A new project kicks off, the team is eager, and the goals are clear. Tasks are assigned, deadlines set, and we dive straight into delivery mode. But somewhere along the way, communication frays, assumptions pile up, and collaboration starts to feel more like coordination. Sounds familiar? In this talk, I’ll take a step back to explore what often gets overlooked in the rush to execute: the power of intentional human connection and communication. At the heart of every effective team lies a strong foundation - and that’s where the team contract comes in. I’ll delve into the core components of a well-designed team contract. You'll walk away with practical tools and deeper insight into how investing time in a collaborative, flexible team contract can lead to stronger cohesion, higher productivity, and greater shared success.

---

Thread Pool Queue Wait Time: The Bottleneck even AI couldn't find

Session type: PERFORMANCE

Many different systems behave surprisingly similarly: they rely on threads or thread pools, make HTTP requests in blocking or non‑blocking mode, and parse JSON while executing business logic. But sooner or later they begin to slow down - like driving through a city during rush hour, when every street hides another traffic jam. In this talk, we’ll explore where queue wait time actually appears in our systems and how to spot it. All insights come straight from real production data. Sometimes adding more threads does make things faster.

---

Supply Chain Compromise: The Anatomy of the Attack and the Blueprint for Defense

Session type: SECURITY

The modern software supply chain is under assault, with the developer environment and CI/CD pipeline forming the critical, most privileged target. The Shai Hulud 2.0 NPM worm demonstrated this perfectly: by backdooring over 700 popular packages and exploiting developer and CI/CD systems across platforms like GitHub, GitLab, and Jenkins, this highly automated worm exfiltrated over 33,000 unique secrets and created over 25,000 public repositories to dump stolen credentials. This talk dissects the anatomy of the breach to reveal the universal attack patterns, such as context injection, dependency confusion, and sophisticated secret exfiltration via high-privilege automation. You will learn the defensive principles that contain your blast radius: implementing strict Least Privilege policies, enforcing a Zero-Trust dependency model (using integrity checks and pinning), and transforming static secrets into ephemeral, just-in-time credentials. After this talk, you will recognize the bad practices that enable these compromises, understand how to prevent your pipeline from getting hacked, and extend your security toolbox with automated checks to enforce these universal principles.

---

How To Be a Rockstar Developer

Session type: NEWS

One evening in 2018, Dylan Beattie sat down in a bar, opened a laptop, and wrote a joke: a parody specification for Rockstar, a programming language based on the lyrics to 1980s power ballads. The joke was supposed to end there: a single Markdown file that folks would read, maybe laugh a bit, and then get on with their lives… well, that’s not quite how it worked out. The internet’s a big place, and a little corner of it took Rockstar to their hearts: they found it, they loved it - and then they implemented it. Six years on, Rockstar has shown up in the most unlikely places, from Classic Rock magazine, to Advent of Code, to Carnegie Mellon University and MIT - and each time, it attracts a new wave of aspiring Rockstar developers, with questions about how it works, and suggestions about how to make it better. And so, one evening in 2024, Dylan sat down in another bar, opened another laptop, and wrote another joke: “Rockstar 2.0: The Difficult Second Album”. On one level, Rockstar in 2026 is a stupid joke language based on Bon Jovi songs. On another level, it’s packed with things that would have been impossible even just a few years ago: a project that combines .NET, C#, JavaScript, browser APIs, and web assembly, building on decades of research in parser engineering and asynchronous application development. And yes, it’s still based on Bon Jovi songs. This is the story of Rockstar 2.0. You’ll learn about the history of esoteric programming languages, from INTERCAL, to Piet, to the researcher who taught Perl to speak Latin. You’ll learn what’s involved in creating an entirely new programming language. You’ll see a lot of cool tech, you’ll marvel at just how much engineering can go into one joke, and who knows - you might even qualify as a Certified Rockstar 2.0 Developer.

---

Tour of Agent Protocols: MCP, A2A, AG-UI, A2UI

Session type: AI

There are many emerging protocols around agents. Model Context Protocol (MCP) standardizes how models and agents access external tools and resources. Agent2Agent Protocol (A2A) defines how agents running on diverse frameworks and platforms communicate. Agent to User Interface Protocol (A2UI) defines how agents generate UI and Agent-User Interaction Protocol (AG-UI) defines how agents communicate with frontends. In this session, we’ll deep-dive into each protocol and show how they complement each other. As a bonus, we’ll also see demos on how to use these protocols in agent frameworks such as Agent Development Kit (ADK) to give you practical knowledge to start building your own interoperable agents.

---

Reviewing the Reviewer: Better PR Feedback

Session type: TEAMCULTURE

Imagine a world where opening a PR feels like a standing ovation rather than a walk to the guillotine. In this session, we’ll explore how replacing passive-aggressive 'nits' with incremental, constructive feedback transforms team velocity. High-performing teams don't just write better code; they communicate with precision and less ego to keep the delivery moving.

---

An ultimate tool for your agents - desktop applications reinvented

Session type: AI

I'd like to give lightning talk with some code previews on how we:

• run agents in customer specific long-living virtual machine environments
• provide agents with ultimate tooling to reach their goals
• how to blend local user's data with sandbox environment context

In this talk I am going to reveal some of the details of our implementations of legal agentic AI and how providing agents with virtual machines enabled many use cases unthinkable before. I am also going to focus on how providing correct environment and standard file-based approach can save a lot of development time and simplify things around.

---

Unifying AI integration with Model Context Protocol

Session type: AI

Modern AI applications require more than simple API calls - they need to interact meaningfully with real-world systems. The Model Context Protocol (MCP) standardizes how AI models interact with external tools and resources through a structured client-server architecture, facilitating robust AI application development. The AI community worldwide keeps sharing MCP servers that enable client interactions that open truly remarkable and innovative applications. This talk explores MCP's core capabilities and demonstrates how the MCP Java SDK with Spring AI MCP integrates AI into your existing applications. You'll learn to build server features (tools, resources, prompts) and use client capabilities (sampling, elicitation). We'll cover local, SSE, and streamable-HTTP transports, plus common utilities for progress tracking and logging. Today's intelligent AI applications can understand context, guide decisions, and integrate seamlessly with external services. Through live coding and practical examples, we will illustrate how to implement both client and server components. By attending this session, you will gain a practical understanding of MCP's standardized interfaces and architectural best practices. MCP enables you to build and extend AI-powered applications with agent-like capabilities. Whether you're developing new AI-driven solutions or enhancing existing systems, this talk will equip you with the tools and strategies needed to leverage MCP effectively.

---

Mob Rules, or: how I learned to Stop Worrying and Love Technical Debt

Session type: TEAMCULTURE

Love it or hate it (usually the latter), technical debt is inherent in any long-term engineering effort. Not just software: if you think the Boeing 787 doesn't contain decades-old legacy components, you may be an incurable optimist. Good on you! For the rest of us, though, technical debt is a fact of life, and while we all agree 'technical debt is bad' we often end up in a perennial, soul-sucking arguments that seldom lead to actual progress. Why is that? In this whirlwind tour of past mistakes and existential post-mortems we will deconstruct technical debt, break down its negative consequences and analyze why it's so hard to tackle both technically and organizationally. A well-defined problem is one we can actually move the needle on, and with clarity we can arrive at better strategies. Technical debt may not be a curable disease, but it doesn't have to be a terminal one!

---

JDK 25's new CPU-Time Profiler

Session type: PERFORMANCE

When your Java application is slow, you need to use a Java profiler. Before JDK 25, the built-in Java profiler only allowed you to profile based on execution time, not CPU-time, and those aren’t the same. A method blocked on I/O and a method doing tight computation can look identical… unless you have CPU-time profiling, which lets you focus on what’s truly burning your CPU. In this talk, I’ll introduce you to the new CPU-time profiler in JDK 25 (JEP 509). You’ll learn why the traditional JFR execution profiles can mislead, how CPU-time sampling works under the hood, and how you can now profile your application more accurately without relying on potentially unsafe, external tools. Whether you care about performance or just want to understand your app’s throughput bottlenecks, this talk by one of the minds behind the profiler will give the foundations of profiling and show you why it’s easier than ever with JDK 25.

---

Project Liliput - first free lunch

Session type: PERFORMANCE

Compact Object Headers are one of the most impactful recent improvements to the JVM. This talk explores why object header size matters for modern Java applications, how Project Lilliput reduces that overhead, and what changes under the hood. It then shows how to enable the feature with a single JVM flag and demonstrates the immediate memory, GC, and performance benefits—without requiring any changes to application code.

---

4xx: The Curious Case of a Disappearing Manager

Session type: TEAMCULTURE

The engineering world is changing - sometimes deliberately, sometimes by accident. We see flatter structures, fewer explicit roles, and new ways of getting work done. Often this isn’t the result of a bold organisational redesign, but simple pressure: faster product cycles, shifting market expectations, and the rapid adoption of AI-powered tools that reshape how work is coordinated and decisions are made. Change is nothing new in IT. Yet this time, somewhere along the way, a more unsettling question appears: do we even need managers anymore? This talk looks at what actually happens when the manager role starts to fade, fragment, or quietly shift back into the technical track - and why the same dynamics increasingly affect engineers, tech leads, and other roles as well. As AI systems take on parts of coordination, planning, and signalling, responsibilities diffuse and boundaries between roles become less clear. We’ll explore these changes through the lens of recurring organisational failure modes such as: 417 Expectation Failed, 421 Misdirected Request, 424 Failed Dependency, and 425 Too Early. The stories and insights are grounded in real-world observations, conversations across engineering organisations, and ongoing research - but told from the perspective of everyday engineering work, not theory. This session is for engineers, tech leads, and managers alike. If you’ve felt that something in how engineering organisations work is changing - and you can sense it even before you can fully explain it - come listen. We’ll talk about what to do when the world shifts, and you feel it in the water.

---

GenAI and Java: A One-Year Retrospective

Session type: AI

One year ago at GeeCON, I presented “Say ‘Hi!’ to Spring AI and LangChain4j”, introducing these tools as the new frontier for Java developers. But 12 months in the AI space feels like an eternity. Since then, the landscape has exploded with the Model Context Protocol (MCP), Agentic Systems, and a wave of new tools. Once again, let’s look beyond the buzzwords. It is time to verify if we are ready to take these shiny new toys out of the safe haven of conference demos and into the harsh reality of production environments. Join me as we seek answers to critical questions:

• How has the GenAI landscape truly changed over the last year?
• Are GenAI solutions ready for enterprise-grade systems without keeping architects up at night?
• Has a clear leader emerged among AI frameworks?
• Has the industry finally addressed security, performance, and testability concerns?
• How do we design systems where deterministic logic meets probabilistic models?

All of this will be backed by real-world stories, examples, and lessons learned from the trenches.

---

Why Bad Code Quality Is Not (Only) Your Fault

Session type: TEAMCULTURE

Code quality is often seen as the developer's responsibility, but the reality is that many roles influence the quality of code—starting with business decisions. In this talk, I will share a real-world example where simplifying redundant business rules, identified by a business analyst, led to cleaner, more maintainable code. We will dive into how collaboration between developers, business analysts, product managers, and other stakeholders can shape code quality from the ground up. By understanding how business logic, requirements, and communication impact the codebase, teams can avoid unnecessary complexity and create software that is simpler to maintain and scale. Whether you are a developer, product manager, or analyst, you will leave with a new perspective on how your role plays a part in building high-quality software. If you have ever thought code quality is solely a developer's problem, this talk will show you how it truly is a shared responsibility.

---

Live Coding The Hive: building a microservices-ready modular monolith

Session type: ARCHITECTURE

After a decade, the industry has realized that poorly designed microservices can easily turn into a distributed monolith, even more problematic than the spaghetti monolith they aimed to address. To tackle this issue, the concept of a modular monolith is emerging as an alternative approach. However, the challenge still lies in effectively splitting it without falling into the pitfall of tightly coupled modules. If this step is not managed carefully, it may later become impossible to split the monolith into separate services when it becomes necessary. The Hive pattern helps you build  a microservices-ready modular monolith, by leveraging multiple hexagonal architectures and vertical slicing, each module is loosely coupled and ready to be extracted as a separate service. During this live coding session, we will begin with a legacy spaghetti monolith and migrate it step-by-step to a Hived modular monolith, wrapping up with a demonstration of extracting a module and transforming it into a separate micro-service.

---

Pairing with Claude: My Experience Using AI for Test-First Development

Session type: AI

AI pair programming is generating plenty of hype, but does it actually work? This talk shares my real-world experience using Claude as a pair programming partner while practicing Test-Driven Development and Behavior-Driven Development. I'll walk through concrete examples of how Claude assists with test-first workflows-from writing specifications and test cases to implementing production code that makes them pass. The good news: it works. Claude can meaningfully participate in TDD and BDD cycles, understanding context, suggesting implementations, and helping refactor with confidence. The honest news: I'm not certain my delivery speed has increased. While Claude accelerates certain tasks, the overall impact on velocity remains unclear. This session offers a candid assessment of where AI pairing shines, where it stumbles, and what realistic expectations Java developers should have when incorporating AI into their test-first practices.

---

Lightning fast services with Server Side Swift

Session type: PERFORMANCE

Swift is widely known as the elegant, safe programming language powering Apple’s ecosystem. But what if the same language could let you build high-performance services that feel —modern, concise, and expressive—while delivering the raw speed of C and it's secret power - seamless C libraries integration? In this talk, I reveal Swift’s best-kept secret: its rapidly growing role on the server. You’ll discover why teams are choosing Swift for backend services, when it makes sense to reach for it, and how it can cut your cloud bills in half without sacrificing performance. Through real-world examples and benchmarks, we’ll explore:

• The unique combination of developer productivity and near-C performance
• Predictable memory usage and latency in production microservices
• Seamless integration with modern cloud infrastructure
• Practical migration stories and gotchas (https://www.somiflow.com biotech lab software, written in Server Side Swift)

Whether you’re battling rising infrastructure costs or looking for a fresh alternative to Go, Java, or Rust, this session will give you a clear playbook for evaluating Swift on the server—and might just convince you it’s the best tool for specific set of microservices, and you’re not yet using it!

---

You’re Absolutely Right (and Other Lies My AI Told Me): Engineering Context for Agentic AI

Session type: AI

My AI coding agent agrees with me a lot. It agrees when I’m right. It agrees when I’m wrong. It agrees while deciding on its own to remove validation logic, rewrite business rules, and confidently explain why this is an improvement. This is what coding with AI agents looks like when context lives in the developer’s head rather than in the system. This talk looks at how developers can make agents less agreeable and more effective by treating shared context as an engineering problem. We’ll show how prompts, rules, and other forms of system context and shared knowledge can be packaged into explicit, reusable units instead of living in ad hoc conversations. More importantly, we’ll look at how that context can be shared and reused consistently across tools and teams, using familiar distribution ideas borrowed from the way we already share libraries via registries and repositories. On top of that foundation, we’ll cover when deterministic scripts are the better choice and how to embed them into agent workflows, how to assess prompt quality using concrete signals instead of “trust me, bro,” and how guardrails like tests and structure help agents fail loudly instead of silently drifting. If your AI keeps agreeing with you even when it’s doing the wrong thing, you’re absolutely right: this talk is for you.

---

The AI-driven future of test environments

Session type: AI

Pre-production environments are often a bottleneck in enterprise software orgs - they're over-contended, slow, unreliable and don't always have the right data available. And this was before AI coding agents arrived - now the environments we use to verify new code can't keep up at all, so we need to radically adjust the way we build, maintain and use environments if we're to get the full benefit of agentic AI. This talk will show what this future could look like, explain the critical role of simulation in enabling it and dive into some specific techniques for using AI to do the heavy lifting of creating and validating simulated environments.

---

Consistency and Coordination Patterns in Event-Driven Architecture

Session type: ARCHITECTURE

AI can help, but we’re still the ones accountable for architectural decisions that can lead to lost messages, duplicates, and other data inconsistencies. In this session, we’ll tackle the dual-write problem, explore the Saga pattern, and compare orchestration vs. choreography strategies for managing distributed workflows. We’ll also dive into the Transactional Outbox and Inbox patterns, showing how we can achieve at-least-once delivery and build idempotent consumers that make our event-driven microservices more resilient, consistent, and reliable. Target Audience

• Backend engineers building event-driven microservices with Spring and dealing with data consistency, messaging, and distributed workflows
• Junior and mid-level developers who want to understand the challenges of keeping distributed systems in sync
• Architects and tech leads responsible for designing reliable distributed systems

Key Takeaways

• How can we handle common challenges such as dual writes, lost, out-of-order, and duplicate messages
• How to choose between orchestration, choreography, both, or neither
• When and how to apply Sagas, Transactional Outbox, and Inbox patterns, including their trade-offs

---

82 Bugs I Collected in a Year You Won't Believe Made It to Production Talk

Session type: TESTING

This past year, I made it my mission to collect every bug I encountered while using everyday apps and websites. From minor glitches to major problems, I ended up with a list of 82 bugs that somehow made it to production. These real-world examples are more than just interesting - they're also embarrassing mistakes that teach important lessons for making software more reliable and improving how we test it. In this talk, I will show the different types of bugs I found and what they reveal about common mistakes in software development. I will also highlight areas that are often overlooked but are crucial to the quality of your product. By looking at these bugs together, I'll show you how to avoid them, so these issues don't reach your users. Whether you want to make your code more reliable or reduce the time from ticket creation to fix, I'll share actionable advice you can apply the next day. Join me to learn from the embarrassing mistakes that even popular apps couldn't avoid - and take-home strategies to prevent them in your software!

---

AI-Powered Product Data Quality: Automated Scoring at Scale Using LLM Vision

Session type: AI

Poor product data costs retailers millions in returns, customer frustration, and lost sales – but manual quality checks don't scale to millions of SKUs. This talk presents our Product Data Quality platform that automatically scores product attributes for completeness and accuracy using LLM-powered image analysis. The system compares stored attribute values against what's actually visible on product packaging images, flagging discrepancies like incorrect weights, missing allergens, or wrong descriptions. We cover the scoring methodology (completeness via applicability rules, accuracy via GPT-4 Vision), the event-driven architecture that processes products in real-time, and how we're building feedback loops to continuously improve data quality across the product catalogue. This presentation delivers the most value to daily practitioners and advanced users who are familiar with real-world data challenges and production-grade systems.

---

Authorization & Dependencies: the two ways apps betray us

Most breaches don’t start with elite hackers. They start with us shipping software that lies. Telling users you’re not allowed, while the backend quietly says sure. Pipeline tells teams this build is ours, while it runs whatever code showed up today. OWASP Top 10:2025 keeps Broken Access Control at the top for a reason: authorization mistakes scale brutally. In this talk we’ll dissect high‑impact 2025 failures where everyday patterns IDORs, missing object-level checks, confused roles, weak tenant boundaries turned normal endpoints into data extraction APIs. Then we’ll pivot to the second betrayal dependencies and supply chain. Including incidents where trusted libraries and CI/CD components were compromised and secrets spilled not because the app was vulnerable, but because the build was. The through-line is simple: modern systems run on implicit trust. Attackers don’t break crypto they exploit assumptions. We’ll finish with defenses that don’t require slowing down: make authorization a testable invariant, and regain supply-chain control with SBOMs, provenance-aware builds, and continuous dependency monitoring. The goal is not compliance. The goal is to make betrayal expensive and detectable.

---

AI-Assisted Coding Beyond the Vibe: Craft, Economics, and the Human at the Controls

Session type: PANEL

Discussion Panel

---

Short-Term & Long-Term Memory in an AI Agent with Spring AI

Session type: AI

In this session, we will explore how to build an AI agent with Spring AI. I will show you how to interact with LLMs using the Chat Client API, how to use short-term memory (STM) using chat history, and how to implement long-term memory (LTM) using embedding models and MongoDB. We will also cover how to build a chat-based web UI for the agent, and how to create MCP servers and MCP tools for agents to use. Key takeaways:

• Building AI Agents using Spring AI
• Spring AI Chat Client API
• Short-term memory (STM)
• Long-term memory (LTM)
• MCP Servers
• MCP Tools

---

Java 27 and Beyond: What Excites You, and Which Myths Need to Die

Session type: PANEL

A new version of Java arrives every six months, and yet some of the platform's most anticipated changes (like Project Valhalla) have been in development for years. As Java 27 approaches, this panel asks experienced practitioners an honest question: how exciting are these releases really, and do they solve the problems developers actually face? While the release cadence is fixed, the impact of each release is not. Some releases land features that genuinely change how developers work. Others lay important groundwork that is harder to feel day to day. And with many teams still on older LTS versions, even meaningful progress can take time to arrive where it matters. This panel will explore what has genuinely excited practitioners about the direction Java is heading — and what has not. Which long-standing myths have recent releases finally put to rest, and which challenges remain unsolved for now? This is a conversation about where Java is going, and what it still needs to get there.

---

“It’ll Take an Hour”: A Half-Year Agent System

Session type: AI

We wanted an answer to a simple question. The kind you expect to get done before lunch: take yesterday’s customer tickets and check if anything interesting happened. That worked. So the next request was obvious: “Cool. Can we get the same report for the last month?” That’s where it went wrong. One day of data ended up taking over 30 minutes to process, with recursive batching and thousands of LLM calls burning millions of tokens just to produce a single report. This talk is a postmortem of how a straightforward script turned into a slow, fragile, complex system. We’ll look at when agents actually help, when they’re just expensive indirection, and how to notice you should stop adding “one more improvement,” rip half of it out, and ship something boring that actually works.

---

Can LLMs Play Games?

Large Language Models are increasingly used to write production code, and agentic approaches promise systems that can plan, generate, execute, and refine code autonomously. But how far can we really go? Can LLM-generated code handle real-time constraints, continuously changing state, and imperfect APIs? And more importantly: do software engineering fundamentals such as SOLID principles, design patterns, and clean architecture still matter when AI writes the code? This talk explores these questions using battlejar.it — a Java-based real-time playground where autonomous “commanders” interact with a live game loop. The project serves as an experimental environment for observing how LLM-generated code behaves under pressure, including tight timing constraints, partial observability, and continuously evolving game state. The session presents multiple implementations of game-playing clients generated with the help of LLMs. These examples are used to analyze how such code behaves in practice, where it succeeds, and where it breaks down when exposed to real-world conditions rather than isolated tasks or static problems. As a supplementary experiment, the talk briefly touches on agentic approaches, where an LLM is allowed to iteratively reason, run code, observe outcomes, and adjust its behavior. This session targets Java beginners and daily Java users, especially those at the beginning of their journey with AI-assisted development. Prior AI experience is not required — curiosity is enough.

---

Enterprise Java in the Age of AI: Ready, Rethinking, or Reinventing?

Session type: PANEL

---