Cool Features in JUnit and AssertJ

This session highlights the best features of the JUnit and AssertJ testing libraries. That will include running tests in parallel, parameterized tests from a variety of sources, custom extensions for callbacks, and much more.

Mockito Features and Best Practices

This session shows the features and optimal ways to generated mocks, stubs, and spies with Mockito. Find out when tools like Mockito are useful and how best to employ them to diagnose issues in your code. Features covered will include creating mocks and stubs, mocking final methods and classes, mocking static methods, and spying on existing classes. It will also cover when NOT to use mocks and stubs, so you don't waste time testing the wrong things.

Spring AI

The experimental project Spring AI is based on ideas from other libraries, like LangChain4J. It provides a systematic way of incorporating the OpenAI APIs like ChatGPT into Java systems. Spring AI includes capabilities like prompt templates, output processors, data loaders, and basic Spring dependency injection to make it easy to work with and customize AI tools.

Spring with Kotlin

The Kotlin language adds capabilities like reified types, domain-specific languages, sequences, and even coroutines to the JVM. The Spring framework has always been friendly to non-Java languages on the JVM, and Kotlin is no exception. This session will review great ways to incorporate Kotlin capabilities into Spring applications, including Spring Boot and Spring Data.

A Data-Oriented Programming Approach to REST APIs

This session will use records, sealed interfaces, and pattern matching for switch to access RESTful web services. The approach takes advantage of concepts from Data-Oriented Programming like immutability, explicit data representations, and expressive behavior. At least one example will involve making text and vision requests to an AI service, and how to implement that effectively using Java 21+.

A Java Tier List: Ranking the Features from Java 1.8 to 25

In this session, we'll rank the features added to Java between versions 1.8 and 25. Those include the basic functional features like streams, lambdas, and method references, through code improvements like switch expressions, records, sealed interfaces, and pattern matching, up to virtual threads, unnamed variables, and stream gatherers. Vote for your favorite (and/or least favorite) feature!

JUnit 5's Best Features

The team that rewrote JUnit in version 5 did a fantastic job improving the platform while maintaining backward compatibility. Many Java developers don't realize how many new cool capabilities have been added to the framework since the initial 5.0 release. This talk will cover topics like the set of useful functional interfaces available, how to do parameterized tests with various sources, lazy loading of error messages, and more.

LangChain4j: The Awesome Framework for AI and Java

This workshop helps you add AI capabilities to your Java systems using the excellent LangChain4j framework. Add chat capabilities, image generation, vision models, text-to-speech, transcription, and more, quickly and easily. Retrieval-Augmented Generation (RAG) will also be included, using a variety of sources, including pdf, HTML, Word docs, and URL resources. The workshop will also demonstrate how to access models added to your local machine using the Ollama system.

Managing Your AI-Driven Manager

The threat to your job isn’t that an AI can replace you — it’s that a manager will think AI can replace you. This talk covers how to build a relationship with your manager that makes you their primary technical ally. The idea is to become the person they trust to evaluate both the benefits — and the costs — of using AI tools, showing where they can help and where you really need to be careful using them. In a rapidly changing world, you can become the person your manager relies on to give them good advice, all while you get to enjoy playing with the latest toys.

Whispers of the Lost Hartford: An AI Opera Experience

Two AI tools are used to create a short libretto for a classic opera given a frankly ridiculous situation. Another model acts as a reviewer to evaluate the result. Illustrations are generated using an image generator. Snippets of music are created from parts of the text using a music generator. A podcast is then generated discussing the quality and historical ramifications of the opera, using yet another model. It's AI models all the way down, with appropriately tragic results.

Cool Claude Code Capabilities

Learn everything worth knowing about Claude Code in a single session. That includes the obvious things, like installation and basic prompts, but also how to customize your status line, how to define your own custom slash commands, how to add and use MCP servers, how to create sub-agents, and more. If they add cool new features between now and the conference, we'll cover those, too.

I've been giving training courses on Claude Code for months now (which is a long time in this world), so I'll fill the longest time block you can give me.

Agentic Commerce: What Happens When We Stop Blocking the Robots?

For thirty years, commerce sites have treated automated buyers as the enemy. Now customers are sending AI agents to shop on their behalf, and the card networks, Google, OpenAI, and Stripe have all shipped protocols that assume merchants will let them in. Giving an agent tools turns out to be the easy part. Giving it bounded authority to spend someone else's money safely is the real engineering problem.

This session walks the merchant-side "front door" one step at a time: discovery, connectivity, identity, authorization, approval, payment, and evidence. Each step is motivated by a live failure against MockHub, a working mock ticket marketplace: an identity binding that lets an agent read the wrong customer's orders, a spending limit that checks the wrong number, and an agent that approves its own purchase because the approval tool was reachable. Then you see the correction as real code, with Spring AI and the Java MCP SDK doing the work.

You'll leave with a seven-step checklist, an understanding of where MCP, AP2, ACP, UCP, and TAP each fit, and a public repository with runnable examples for every step.

- Format: presentation with live demos against a hosted platform. Recorded fallbacks exist for every demo if the venue network fails.
- Duration: 50 to 60 minutes. A half-day or full-day hands-on workshop version exists, with labs in Java, Python, and TypeScript, if the organizers want one.
- Audience: intermediate. Developers and architects who own a transactional system, plus tech leads and product people deciding whether to open it to agents. No prior MCP experience needed.
- Requirements: projector and internet. Nothing for attendees to install.
- Materials are public at github.com/kousen/agentic-commerce.
- The specification landscape changes quickly. The talk is updated before every delivery to reflect current status.

Bring Your Own Model: Running Anything Inside Claude Code

Claude Code is usually described as Anthropic's coding agent. It is more useful to think of it as a harness. A loop prompts a model, runs tools, checks results, and decides when to stop, and the model is a swappable part. Once you see it that way, interesting doors open. You can point the same harness at any model on OpenRouter, run a free open-weight model for prose and a frontier model for code, and find out which parts of "agentic coding" were the model and which were the loop.

This session shows how to do that in both Claude Code and the Codex CLI, since the same trick works in both harnesses, and then spends most of its time on what happens next. The loop is the bill, so I'll show how a free model cost me nineteen dollars in an afternoon. Cheaper models fail in different places than expensive ones, so I'll show a text-only model that reports "model not found" when you paste a screenshot, and what it takes to notice. Verification is the part you cannot outsource, so we'll look at the ways an agent quietly moves the goalposts and the guardrails that stop it. We'll finish with the loop ladder, from an interactive session through headless runs to hosted agents, and which rung each kind of work belongs on.

You'll leave with a working multi-model Claude Code configuration, a cost model that predicts the bill before you run the loop, and a short list of what to verify no matter which model did the work.

50-minute talk. Intermediate to advanced. Live demos with a recorded fallback. Material drawn from my forthcoming O'Reilly book, Claude Code: Up and Running.

Someone Vibe-Coded It. Now It's Your Problem.

Non-developers are shipping working software now. A marketing lead builds an internal tool over a weekend, a founder ships a prototype that gets customers, a researcher writes the script the whole lab depends on. Then the tool has to be dependable, and someone has to make it so. That someone is increasingly going to be you, and the job is not "rewrite it." The job is to move it up a scale without losing what already works.

I think of projects as doghouses, cabins, and skyscrapers. A doghouse is small, casual, and shipped in a weekend, which is the vibe coding sweet spot. A cabin is modest but dependable, with a testable core and explicit boundaries. A skyscraper adds coordination, review gates, and CI discipline because other people have to work inside it. Most inherited vibe-coded projects need to become cabins, and the mistake in both directions is expensive. Build a doghouse like a skyscraper and you never finish. Run a skyscraper like a doghouse and it fails in ways that cost real money.

This session walks the doghouse-to-cabin transition on two real projects using Claude Code. A single-file JavaScript app that a request for tests forces into a testable core with boring DOM glue. A Spring Boot certificate service that started as a joke and ended with property-based tests on its cryptography. Along the way we do the read-only orientation pass that makes the agent mark where it is guessing, write the project memory that stops the next session from re-learning everything, decide what actually needs a test, and catch the failures that come with the territory. Tests the agent rewrote until they passed. A confident architecture map that disagreed with the code. A refactor that quietly changed behavior.

You'll leave with a triage sequence for any inherited agent-written codebase, the prompts that drive each step, a rule for knowing when to stop, and a public repository showing both projects before and after.

50-minute talk. Intermediate. One example is vanilla JavaScript, the other is Java and Spring Boot, so no framework knowledge is assumed. Material drawn from my forthcoming O'Reilly book, Claude Code: Up and Running.