Craft Conference 2026

AI agents are writing code pretty much everywhere. And yet, most teams and companies are not seeing that dramatic productivity gains… or are they?In this talk, Gergely shares an overview across the industry: how leading AI labs use the tools they are building, what Big Tech is doing, and how startups and more “traditional” companies are doing.We’ll see what is working, what is not, and what lessons different teams are learning about this new way of building software.

speaker

Gergely Orosz

stage

Main Stage

time

09:40 - 10:40

tags

modernization, management, technical excellence

From early cloud computing to today’s agentic systems, Reuven Cohen has spent his career at the edge of major technology shifts—helping define how new paradigms move from experimentation into real-world adoption.In this keynote, Reuven will explore the fundamental shift underway in artificial intelligence—from static tools to dynamic, collaborative systems.Drawing on his work at the forefront of agentic infrastructure, he will introduce the principles behind this transformation and what it means for organizations, builders, and the future of software development. He will also introduce the Agentics Foundation, an initiative focused on advancing understanding and adoption of agentic AI systems.Reuven will share insights from his latest work developing production-ready agentic architectures and multi-agent environments. He will explore how organizations can move beyond traditional tooling toward fully composable, intelligence-driven systems—highlighting practical approaches, architectural patterns, and lessons learned from real-world deployments.Through real-world examples and emerging patterns, this session offers a clear view into how intelligent systems are reshaping workflows, decision-making, and creation itself—and how to begin building within this new paradigm today.

speaker

Reuven Cohen

stage

Main Stage

time

11:00 - 11:45

speaker

Gregor Hohpe

stage

Main Stage

time

12:00 - 12:45

tags

architecture, domain-driven design, software architecture

The software industry is shifting at a rate we’ve not seen in recent times, driven by the contradictory pressures of rapid AI innovation and a renewed focus on cost optimization. We are moving beyond the era of predictable systems—managed by traditional project plans, runbooks, and repeatable tests—into an era of complex, sociotechnical systems that often behave nondeterministically. In this chaotic landscape, the nature of engineering work isn't disappearing; it is moving toward higher levels of abstraction.This session explores how to navigate the coming complexity by embracing a risk-first approach to both leadership and system design. We will examine why AI/ML is not just another automation layer but a shift that requires new strategies for building and maintaining reliable systems, including: risk-driven software planning, abstract system design, system-level testing, and a culture that allows for experimentation.

speaker

Michelle Brush

stage

Main Stage

time

14:00 - 14:45

tags

architecture, code quality, leadership, scaling, software development, software architecture, technical excellence

Software used to be about building a thing and shipping it. That era is ending. The product is no longer the artifact — it's the loop that finds problems, writes the fix, ships it, and learns. Your job isn't to build the product anymore. It's to build the system that builds the product. This talk is about what that actually looks like: self-driving products, MCPs as the new front door, and how to get a team to stop shipping features and start shipping loops.

speaker

James Hawkins

stage

Main Stage

time

14:55 - 15:40

tags

product thinking, organization

Coding agents are getting good enough that “can the model write code?” is no longer the most interesting question. The more important question is: what kind of engineering system do you need around the model to make its work useful, repeatable, and trustworthy?This talk is about Harness Engineering: an agent-first way of building software where the engineer’s job shifts from directly producing every implementation detail to designing the goals, constraints, context, tools, checks, and feedback loops that let agents do real work. I’ll share practical patterns for scoping tasks, shaping context, building guardrails, and deciding where agents are already strong versus where they still fail in frustrating ways.The argument is that the biggest change comes from more than just improvements in model capability; increasingly, higher quality from agents comes from changes in the operating model of software development itself. If humans increasingly steer and agents increasingly execute, then the hard part becomes building the harness that makes that collaboration actually work.

speaker

Ryan Lopopolo

stage

Main Stage

time

16:00 - 16:45

tags

architecture, design patterns, software architecture, software development, ai, artificial intelligence, code quality

Oh look, another session about AI! Your social media feeds are already flooded with agentic this and spec-driven that; one-shot rewrites and everyone-is-a-programmer-now.I want to share some models and metaphors that are helping me make sense of this new world: why Ward Cunningham hates printers, how riding a fixie isn’t really cycling, why Claude is just a mercenary contractor, how test-first is the new TDD.Beyond the hype, we should still care about iterative development, bounded contexts, decent tests, intention-revealing names. And AI is not going to replace junior developers any time soon, instead it is something... other. I don’t use genAI to go faster or produce more, at least not primarily. Instead it is helping me do 'adjacent' things, allowing me to focus where I want to rather than where I otherwise would have to.My goal is to give you a more nuanced take on generative AI, to help you cut through all the noise and get actual work done.

speaker

Daniel Terhorst-North

stage

Main Stage

time

16:55 - 17:40

tags

ai, code quality, programming, testing, tdd, llms, tools, unit tests

You already know what you need to do.You’ve known for a while.And you’re still waiting.In Crossing the Line, Veronica Lynn Clark asks the question most of us spend our entire lives avoiding — not what do I want, but what is stopping me from going after it. Through raw honesty and stories earned from real experience, she challenges every person in the room to look at the moments they overrode themselves, and to consider what has been waiting on the other side of that choice all along.This talk will not give you a framework. It will give you a mirror. And by the time you leave, you will know exactly what line you’ve been afraid to cross — and why today is the day to cross it.

speaker

Veronica Lynn Clark

stage

Main Stage

time

17:50 - 18:50

tags

psychology, self confidence, unlimited potential, leadership, imposter syndrome, TECH LEADERS, product thinking, management

In the Forest & Desert, Bethany Andres-Beck identifies two stable attractors for software development:  * Forest--assume sufficient resources, freeing the team to create even more resources.  * Desert--assume scarcity, pressuring the team to consume irreplaceable resources & limiting future options.What happens when we add augmented development to the Forest or the Desert? Amplification.This talk introduces the Forest & Desert distinction, showing how augmented development affects both. We close with tips for moving from Desert to Forest aided by enlisting the Genie.

speaker

Kent Beck

stage

Main Stage

time

09:10 - 10:10

tags

programming, tdd, software development, design

Understanding the system we are about to change has always been one of the hardest parts of software development. For decades we've developed practices - reading tests, sketching dependencies, talking to the people who built it - to recover the theory of a system before we touch it. AI has scrambled this. It can help us understand code faster than ever, and it can also produce code faster than we can understand it. The same tool sits on both sides of the comprehension problem.This creates a new kind of debt. Technical debt is visible in the code; comprehension debt is invisible until something breaks, and you can't refactor your way out of it — you have to learn your way out, which is harder than writing the code was in the first place. Meanwhile, the skills that let us intervene confidently in complex systems are the same skills that atrophy when we stop exercising them.In this talk I'll work through where AI helps us understand systems, where it quietly hinders us, and what it means to stay "in the loop" as a developer when the loop is optional. I'll share practices I've been using and seeing others use — hypothesis-first reading, having the AI quiz you on the systems it generates, adversarial explanation, and comprehension reviews - that keep authorship and understanding with the humans who have to live with the code. The goal isn't to slow down. It's to make sure that when something goes wrong someone still knows what the system actually does.

speaker

Michael Feathers

stage

Main Stage

time

10:30 - 11:15

tags

design, software development, code quality, ai, artificial intelligence, programming, legacy code, technical debt, technical debt management, architecture

In the spring of 2002, Walter Murch, a three-time Oscar winner and the most respected film editor alive, got news he wasn't expecting. He had just persuaded the producers of Cold Mountain to let him edit the film entirely on Apple's Final Cut Pro. It would let him do things no traditional editing system could, but no one had ever attempted it on a major motion picture. Now Apple was telling him the software wasn't ready yet, and they couldn't support him if he proceeded.Murch did it anyway. His team packed up a rack of off-the-shelf Macs, shipped them to the set in Romania, and built an editing system from scratch in a country where nobody could help them if it broke.Murch bet his reputation on a $999 tool that not even its maker thought was ready. He saw what Apple couldn't, and the way he acted on that vision is a pretty good blueprint for anyone looking to ride a wave of disruption instead of getting swept aside by it.

speaker

Nickolas Means

stage

Main Stage

time

11:30 - 12:15

tags

leadership, management, ai, artificial intelligence, psychology

With AI coding agents becoming increasingly popular, the big challenge becomes how to stay in control while harnessing the power of AI assistance. In this talk, Gojko presents the results of an industry research of early adopters of AI coding agents, who found ways to systematically apply structured engineering practices and keep humans in the loop, but avoiding AI slop. Vibe coding can significantly cut time to a prototype, but it can also create an unmaintainable mess. Learn how to add guardrails and constraints to automated AI coding agents, so they can produce code as good as humans, but significantly faster. Find out good patterns and practices how to keep humans in the loop to make the key decisions, and create effective feedback cycles to keep AI agents on the right path. 

speaker

Gojko Adzic

stage

Main Stage

time

13:45 - 14:30

tags

product thinking, ai, llms, programming, race against the machine, technical excellence

AI agents are powerful because they are not just deterministic software components. They can explore, investigate, synthesize, recover, and adapt. That is exactly what makes them useful, and exactly what makes them hard to trust.The mistake is trying to force agents to behave like traditional software. The better pattern is to give each part of the system the job it is good at: tools for certainty, claws for discovery, and an architecture that keeps the loop grounded in reality.This talk tells the story of NemoClaw: how it started, what we learned while building it, and why it changed the way we think about agentic engineering systems. NemoClaw brings together OpenClaw, Hermes, OpenShell, local inference, policy controls, sandboxed execution, credentials management, and lifecycle tooling to make always-on agents more practical in real engineering workflows.We will go into what NemoClaw does and why it matters. What makes “claw style” agents different? How do we let agents act without giving them unlimited trust? How does a sandboxed shell change the safety model? What belongs in policy? What should be routed through deterministic tooling? What should be left to probabilistic exploration? And how do we give them memory, in a manner that allows them to fufilly the promise of being the first kind of software that truly gets better with use.I will also share how we use claws in our own engineering pipeline. We use agentic workflows to build, test, debug, evaluate, and harden NemoClaw itself. That feedback loop has become one of the clearest signs of where this is going: the best agent platforms will not just run agents, they will help improve the systems they are part of.The broader vision for NemoClaw is to make agentic software feel less like bespoke magic and more like an engineering substrate. Not a chatbot bolted onto a workflow, and not an unconstrained agent wandering through production, but a composable system where agents discover, tools verify, policies constrain, and feedback loops improve the result over time.Attendees will leave with a practical mental model for building reliable agentic systems: when to use tools, when to use claws, where to put boundaries, and how to move from “the agent did something interesting” to “the agent is part of how we build software.”

speaker

Aaron Erickson

stage

Main Stage

time

14:50 - 15:35

tags

ai, artificial intelligence

AI is changing the structure and economics of SaaS and OSS. The myth: AI will let us one-shot everything from scratch, making SaaS, open-source libraries, and frameworks obsolete. The reality: AI makes good components and abstractions more valuable than ever before, because it unbundles the knowledge within them and lowers the cost of assembling them.Real-world problems are complex, and both nature and humans solve them by dividing them up in hierarchical, fractal, and iterated ways. Systems — biological, mechanical, or digital — are built on layers of robust components, which themselves encode the results of earlier feedback loops. Abstraction, encapsulation, and modularity aren't just concessions to limited human cognition; they are part of the physics of successful systems. There is no compression algorithm for experience, and AI makes components that encode experience more valuable, not less. This talk offers concrete predictions about how AI will reshape the software landscape and make the fundamental principles of systems and software engineering even more required:For SaaS: Value shifts from simple glue to complex encoded domain knowledge, composability, efficiency, and operational expertise. Procurement collapses from enterprise sales cycles to agent-driven assembly of components. For OSS: Trivial libraries get replaced and forks abound, while projects with robust test suites and supply-chain provenance provide the real value. For Software Engineering: Teams shrink and roles widen. TDD / BDD, compiled and strongly-typed languages, observability, and progressive delivery all become more important. Come for the myth-busting, stay for the practical framework.

speaker

Randy Shoup

stage

Main Stage

time

15:45 - 16:30

tags

architecture, scaling, software architecture, artificial intelligence, domain-driven design, llms, tdd

High-performing teams don't fail because of bad code or missed deadlines — they fail because of broken communication. Many teams invest in psychological safety training, yet still find themselves stuck in the same dysfunctional patterns — and the reasons why may surprise you. When a message lands as a threat rather than information, the conversation is often over before it begins. In this talk, you'll learn to recognise your personal communication triggers and understand why so many well-intentioned team interventions quietly backfire. You'll also learn some powerful communication protocols borrowed from emergency medicine and aviation that high-performing teams use to stay aligned under pressure. Leave with practical tools you can apply immediately — because when your communication improves, your team improves.

speaker

Joseph Pelrine

stage

Platform 2

time

11:00 - 11:45

tags

psychology, software development, management, organization

When do you need an architecture? How specific should my contracts be? Should I make everything a microservice? Are my services too small? If you are wondering about these questions, you’re not alone. It turns out these questions all relate to architecture anti-patterns and pitfalls - things we do that get us into trouble. In this lively session, Mark Richards talks about some of the common architecture anti-patterns and pitfalls you’re likely to encounter, and ways to avoid these common architectural traps.

speaker

Mark Richards

stage

Platform 2

time

12:00 - 12:45

tags

software architecture, architecture, design, microservices

How do we use objects to model a domain? Whilst Domain Driven Design (DDD) exhorts its practitioners to focus on the domain, it is surprisingly sparse on how we should accomplish that, other than a few patterns whose job is to abstract away concepts that live outside of that domain. What though of the domain model?In Domain Driven Design, Eric Evans is explicit that it relies on usage of Rebecca Wirfs-Brock's Responsibility Driven Design (RDD), which sees allocation of responsibilities as the key technique for splitting our system into co-operating objects. Despite this, many developers who are aware of DDD, know little about RDD. In this talk we aim to set that right with a journey into RDD. In an example-driven talk we will work through analysing a domain using RDD, explaining key techniques such as CRC cards for modelling the domain. Along the way, we will explain key concepts like responsibilities, roles, object stereotypes, and control styles.Finally, we will ask how RDD fits into our current approaches to software development. We will re-explore its relationship to DDD and look at how techniques like TDD can be used to help us uncover responsibilities, roles and collaborators.

speaker

Ian Cooper

stage

Platform 2

time

14:00 - 14:45

tags

domain-driven design, domain model, software architecture, software development

AI coding recently crossed a threshold. Agents stopped producing buggy piles and started shipping code that mostly works. The question is no longer "can it write code?" It's "how do we engineer around the fact that it can?"The answer isn't better prompts. It's the harness: the deterministic scaffolding that lets agents do real work without us reading every line. Tools the agent calls. Skills it loads. Verification gates that decide what ships. Recovery contracts that catch what fails. The harness is what stands between vibe coding and production.This talk walks through patterns for building that harness, anchored in a real system I shipped and haven't touched in months. An AI-driven local events newsletter that scrapes, validates, deploys, and recovers on its own. We'll cover the shared responsibility model for agentic systems, where reasoning owns intent and the harness owns consequences, spec-driven development as the antidote to verification debt, and the language-agnostic patterns that separate prototypes from systems you can trust.You'll leave knowing how to build agents that ship, not just demos that impress.

speaker

Banjo Obayomi

stage

Platform 2

time

14:55 - 15:40

tags

ai, code quality, software development, technical debt, unit tests, llms, architecture, testing

Modern junior programmers and CS graduate students don't have the preexisting technical experience that footnotes blog posts about how much AI has helped professional engineers code. What skills do we focus on in class to help them enter this industry, and what does an AI-enabled tech industry have to teach us about how we learn?

speaker

Chelsea Troy

stage

Platform 2

time

16:00 - 16:45

tags

technical debt, technical debt management, legacy code

speaker

Justin Reock

stage

Platform 2

time

16:55 - 17:40

tags

ai, artificial intelligence, organization, management

Shortly, we are told, machines will be doing all useful work and we will live in a fully automated paradise. How is that going to happen, exactly?

speaker

Ashi Krishnan

stage

Platform 2

time

10:30 - 11:15

tags

artificial intelligence, psychology, TECH LEADERS, vital skills, llms, organization

When you hear “governance,” you might think of red tape, bureaucracy, or someone telling you what you can’t do. But real governance is about alignment and reducing technical risk. And that matters more than ever.In most cases, engineers aren’t deliberately making risky decisions—they just don’t have clear expectations. That’s where good governance comes in. It ensures everyone understands what “good” looks like, gives teams the autonomy to move fast while staying on course, and provides built-in mechanisms to self-correct before small missteps become big problems.In this talk, I’ll break down how to implement governance that actually helps, not hinders, including:Understanding what’s in your software estateBuilding guardrails and policies that work - and automating them!Aligning technology decisions across teamsMaking smart technology choices - and why “boring” is often bestIf you want to reduce risk, improve decision-making, and keep your organization running smoothly—without slowing your teams down—this session is for you.

speaker

Sarah Wells

stage

Platform 2

time

11:30 - 12:15

tags

leadership, organization, management, architecture decision records, maintenance, technical debt, technical debt management

AI is all around us in the digital world. It helps write our emails, schedule our calendars, take better selfies. We accepted Ai into our digital life, and it is very comfortable in the digital world.But what about our real life in the real physical world? We were promised self-driving cars, delivery robots and drones, and robot servants to make our life easier in the real world too. But they are still not really here.The reason is simple: the physical world is really hard. So hard in fact, that there is a separate phase for the efforts and field trying to solve it: Physical AI is taking AI into the real world, solving real problems.What is needed for a robot using physical AI? No matter the exact task and exact robot -every robot has to understand - perceive - its environment, in any weather, day and night, with a sensor setup that makes it affordable to scale.While cameras and lidars are widely used, the oldest sensor - radar - is a bit forgotten these days. In this talk, we will discuss its benefits, disadvantages, and how dedicated radar AI can make them very useful for robots on-road, off-road, indoors, or in-air!

speaker

Andras Palffy

stage

Platform 2

time

13:45 - 14:30

tags

ai, artificial intelligence

There’s no shortage of advice urging platform teams to treat their internal platform like a product, emphasising user empathy, prioritising value over requests, and building trust through consistent care. These are essential practices, but most conversations lean heavily into the socio side of the socio-technical balance.This talk shifts the spotlight to the technical side of platform-as-a-product. Abby will explore what Developer Experience (DevEx) looks like for platform builders themselves, and the often-overlooked technical foundations that make great internal platforms possible.Topics will include:- What observability and testability look like in a platform- How architectural principles (like service design and interface boundaries) shape platform resilience and usability- The tooling and feedback loops platform teams need to stay effectiveIf you’re building internal tools and infrastructure, this talk is for you. Let’s talk about improving your developer experience.

speaker

Abby Bangser

stage

Platform 2

time

14:50 - 15:35

tags

modernization, product thinking, architecture

The Awareness Layer: How Accelerated Engineering Forces Smarter OrganizationsAI has dramatically accelerated the ability to build. What used to take months can now take days, and what took teams can increasingly be done by small, highly capable groups. But this new engineering velocity creates a new bottleneck: organizational awareness. In this talk, Robert Ranson argues that the real constraint is no longer production capacity; it is the ability of leaders and organizations to perceive, interpret, and respond to change fast enough. As software creation becomes radically easier, the winners will not be those who build more, but those who build with better situational intelligence.Drawing from the front lines of agentic engineering, Robert introduces “The Awareness Layer” as a practical strategic framework for modern organizations: an always-on intelligence layer that helps teams detect opportunities earlier, reduce blind spots, prioritize what matters, and make decisions in step with accelerating reality. The session explores why traditional structures break under AI-speed conditions, where the new chokepoints emerge, and how businesses can evolve from reactive management to adaptive, awareness-driven operations. This is a talk for founders, operators, and innovators who want to understand what comes after faster engineering, and, how to build organizations that are actually capable of keeping up.

speaker

Robert Ranson

stage

Focus Platform

time

11:00 - 12:45

tags

ai, leadership, management, modernization, organization, TECH LEADERS

Goal: participants will explore Event Modeling, Specification-Driven Development, and code generation - without writing any markdown.In this interactive workshop, we take rough requirements and turn them into a running system. Starting from a messy idea, you’ll build a visual Event Model that captures behavior, decisions, and data flow. This model becomes a living specification that guides implementation, enabling you to generate code and iterate quickly.You will:Explore Event Modeling hands-on and visualize system behaviorApply spec-driven development without writing extensive documentationGenerate working code directly from the modelContinuously refine the system as you test and experimentBy the end, you’ll have built a working prototype and gained a practical, repeatable approach to going from idea to model to code - and back.

speaker

Martin Dilger

stage

Focus Platform

time

14:00 - 15:40

tags

hands-on, llms, software architecture, software development

Reuven Cohen focuses on a deeper question: What happens when intelligence is no longer just a layer of software, but something built directly into the systems we run on?In this forward-looking workshop, Reuven will introduce Cognitum, his latest venture exploring the convergence of AI infrastructure and next-generation computing.The session will begin with a deep dive into the Cognitum chip, demonstrating how intelligence can be embedded directly in the hardware layer to natively support agentic systems. Participants will gain insight into how this approach enables faster coordination, more efficient execution, and a fundamentally new model for building intelligent systems.Building on this foundation, Reuven will connect these concepts to real-world agentic architectures—showing how hardware and software are beginning to converge into unified, intelligence-driven systems.This workshop is designed for forward-thinking leaders, builders, and technologists interested in where AI infrastructure is heading—and how to start preparing for what comes next.

speaker

Reuven Cohen

stage

Focus Platform

time

16:00 - 17:40

Test‑Driven Development (TDD) has been a stalwart of software engineering for years, delivering reliable, modular code that stands the test of time. As we enter the AI era, TDD isn’t just enduring, it’s evolving. Modern AI capabilities are accelerating the TDD workflow, helping developers explore edge cases, reason about refactoring options, and tighten feedback loops without compromising the discipline that makes TDD effective.This extended, hands‑on session is designed to start your journey into AI‑assisted TDD. We will examine how AI can influence each stage of the TDD cycle and explore the opportunities and tradeoffs that come with integrating these tools into your development practice. Attendees will have time to experiment with the ideas presented and reflect on how AI‑supported workflows might fit into their own environments.Because every team has different constraints, risk tolerances, and levels of confidence in model behavior, this session does not prescribe a single workflow. Instead, it provides starting points, evaluation criteria, and practical guidance to help you develop an approach that aligns with your needs. You will leave with a clearer understanding of how to introduce AI into your TDD practice responsibly and how to evolve your process as your confidence and requirements change.

speaker

Barry S. Stahl

stage

Focus Platform

time

10:30 - 12:15

tags

agile development, tdd, unit tests, ai

The AI testing landscape is drowning in promises: "autonomous testing," "self-healing tests," "AI-generated coverage." After a year of building production agentic systems and watching teams struggle to move past demos, I've learned what actually works—and what's still vendor theater.This hands-on tutorial cuts through the noise. You'll work with the open-source Agentic QE Fleet and Claude Code, progressing through three phases:Build — Extend the Agentic QE Fleet to fit your context. You won't just run existing agents—you'll create or customize specialized agents that address your team's specific quality challenges. Learn the architectural patterns that make agents maintainable, not magical black boxes.Test — Put agents to work on real artifacts. Use Agentic QE agents and skills to verify human-written code, validate agent-generated outputs, and catch the subtle failures that slip past traditional automation. Experience how agents and humans collaborate to find what neither would catch alone.Orchestrate — Coordinate your quality ecosystem using PACT principles (Proactive, Autonomous, Collaborative, Targeted). Integrate the fleet into CI/CD pipelines, IDE workflows, or standalone exploration sessions. The same agents work across contexts—the orchestration determines the value.You'll leave with:A customized agent extending the Agentic QE FleetHands-on experience testing both human and AI-generated artifactsIntegration patterns for embedding Agentic QE into your workflowWho should attend: Engineers, architects, and tech leads ready to move beyond AI demos into production-ready quality workflows.

speaker

Dragan Spiridonov

stage

Focus Platform

time

13:45 - 15:35

AI is transforming how we build software, but it also introduces new ways to leak data, break systems and bypass controls. This talk outlines how to implement a simple AI Security Framework with concrete risks, attack examples and practices your data, AI and security teams can apply today.

speaker

Adam Litter

stage

Focus Platform

time

15:45 - 16:30

tags

ai, architecture, dependency management, llms

Real-world AI adoption, smarter ways of working, and lessons from the front linesThe AI revolution isn’t coming — it’s already altering how we architect products, ship features, and run engineering teams.During this talk, in his signature charismatic style, Sander Hoogendoorn, CTO at iBOOD.com and a seasoned developer with over four decades of coding experience, doesn’t get stuck in theory or hype, but confronts the pressing issues head-on. You’ll get a no-fluff, grounded view from iBOOD — what we’re already doing with AI, how we built it into our systems, and how it shapes the way we work.We will walk through concrete examples, such as using the Responses API, adopting the Model Context Protocol (MCP), embedding AI into our e-commerce workflows, and automating genuine parts of our stack. You’ll see where AI accelerates, and where it fails us.We won’t shy away from the dark side either — vendor lock-in, breaking prompts, model opacity, shifting APIs, and how fast dependency can become fragility. These are real risks that shape architectural and organizational decisions we make daily.To survive exponential speed, we retired many practices: no Scrum, no rigid ceremonies, no big upfront plans, no pull requests or code reviews. Instead, we embrace working in fluid autonomous microteams, continuous learning, experimentation, and radical adaptability.Expect an honest, fast-paced, and experience-driven session — mixing architecture, culture, and practical insight — on what it truly takes for developers and teams to survive and thrive in the age of AI.

speaker

Sander Hoogendoorn

stage

Yellow Stage

time

11:00 - 11:45

tags

ai, artificial intelligence, maintenance, modernization, tools, code quality

In a world of countless AI assistants and helpful agents, why does it feel like we have less time than we did five years ago (or even six months ago)? Sociologist Hartmut Rosa argues that technical acceleration inevitably leads to social change that outpaces our ability to adapt. In tech, this manifests as "Frenetic Standstill"—doing more work while achieving less meaningful progress.This session provides a practical toolkit for teams navigating the AI-shift. We’ll discuss emerging patterns and pitfalls in AI-assisted or AI-executed work. We will also consider the potential of AI to allow space for human resonance in the craft of software development and in life.

speaker

Cat Swetel

stage

Yellow Stage

time

12:00 - 12:45

tags

ai, artificial intelligence, leadership, management

How do you reason about which tools to provide your developers? What is the value of finding a class of bugs earlier in the workflow? How late in the software release process is too late to stop the pipeline to fix a defect? How do we reason about the value of faster deployments? This talk will attempt to answer questions like these, using the "Develop, Deploy, Operate" model. This work attempts to condense decades of platform engineering arguments into a model for reasoning about software cost, along with a few key insights for guiding platform and tooling investments.

speaker

Titus Winters

stage

Yellow Stage

time

14:00 - 14:45

tags

TECH LEADERS

Modern applications are still dominated by glue code: manual wiring between state, UI, and navigation that is repetitive, error-prone, and hard to reason about. Meanwhile, AI-assisted code generation offers speed but often lacks reliability, transparency, and can be costly due to large code outputs and iterative refinement.This talk presents an alternative: treating applications as specifications that can be compiled into well-typed programs, with AI assisting in writing the specification rather than generating code directly. AI doesn’t build the application, it helps you describe it. Because the specification is compact and structured, it requires significantly fewer tokens than full code generation, making AI assistance more efficient, more predictable, and easier to control.We model applications as screen-local behavior, a transition graph for flow, and WebSharper.UI templates for presentation. A compiler synthesizes the application from this specification and verifies that behavior, UI, and navigation fully agree. If the generated program type-checks, the result is a complete, fully wired application with no missing bindings or hidden glue code, essentially shifting development from writing and debugging code to specifying intent, with the compiler enforcing consistency end-to-end.

speaker

Adam Granicz

stage

Yellow Stage

time

14:55 - 15:40

tags

programming, software development

For developers who want to improve their craft there's no shortage of published, promoted and proclaimed principles they can choose from to shape their style and craft their code. Whether it's the alphabet soup of SOLID principles or old school classics like Information Hiding and the Separation of Concerns, there's a lot of advice out there. Some of it even makes sense. And some of it is well supported. But a lot of principles are misunderstood, misapplied or simply mistaken.In this talk we'll take a look at (and take down) a few principles, highlighting the real lessons we can apply to our code — lessons supported by sound rationale rather than just strong opinions.

speaker

Kevlin Henney

stage

Yellow Stage

time

16:00 - 16:45

tags

software development, code quality, programming, design, design patterns, dependency management, domain model, testing, unit tests, technical excellence

In this talk, we're going to look in detail at AI Infrastructure, and the nuances it presents to modern day engineers. The way we deploy and manage software on this type of platform is very different from the distributed systems you are used to, and it's important to understand how they work, and how to deploy software to them, in a way that is efficient and cost effective. Consider that one rack of GB300s can cost millions, and the need to understand and optimize your software on these systems becomes immediately apparent!You'll walk away with a solid foundational understanding of how AI Infrastructure works, and how you can start to approach using it.

speaker

Bryan Oliver

stage

Yellow Stage

time

16:55 - 17:40

tags

ai, artificial intelligence

When we work with another person, we constantly adjust through their emotions - that feedback loop helps us stay aligned and think together.With AI, that loop is missing and nothing pushes back.Whatever you bring into AI, it will amplify—and as it improves, that amplification only grows stronger.Will you keep up?

speaker

Ilyas Landikov

stage

Yellow Stage

time

10:30 - 11:15

tags

ai, artificial intelligence, llms, programming

speaker

Christopher Grainger

stage

Yellow Stage

time

11:30 - 12:15

speaker

Kashyap Murali

stage

Yellow Stage

time

13:45 - 14:30

tags

llms, management, ai, artificial intelligence

Genetic algorithms "learn" to make better decisions by making continuous improvements in strategy based the fitness of that solution for survival. These algorithms, modeled after Darwinian evolution, can solve complex optimization problems across many domains - from resource allocation to network design to automated testing. In this talk we'll define the DNA of our solutions, explore how to represent different types of problems in genetic terms, and examine the parameters that control how solutions evolve and improve. You'll leave with practical knowledge of how to apply these powerful techniques to your own challenging problems.

speaker

Barry S. Stahl

stage

Yellow Stage

time

14:50 - 15:35

tags

artificial intelligence

AI can generate code.But without structure, it generates entropy.As AI becomes embedded in development workflows, the critical question is no longer “Can agents write code?” but:Can they work together safely inside a real system?In this session, Florin Coroș presents an approach built on two complementary pillars: a development process explicitly designed for Agentic AI, and an Application Infrastructure that encodes Clean Architecture decisions directly in code.The development process defines how multiple Agent Types collaborate through iterative steps grouped into incremental phases, with clear approval gateways between them. This creates controlled progress, where each step is validated before moving forward. The Application Infrastructure provides the structural guardrails those agents operate within, enforcing separation of concerns, dependency direction, and modular boundaries.The focus is on the .NET and C# ecosystem, demonstrating how structured infrastructure and coordinated agents operate within real-world backend systems, using tools such as GitHub Copilot to enable and orchestrate agent-driven development.The result is not just speed, but consistency, predictability, and long-term system integrity.

speaker

Florin Coros

stage

Yellow Stage

time

15:45 - 16:30

tags

artificial intelligence, ai, architecture, design, software development

What actually happens when we make a decision about a software architecture? How do we map from a business context to a component structure? How do we make decisions about granularity and arrive at monoliths or microservices? Is it heuristic? Is it a repeatable pattern? How do we know if it’s right? Why do we get this wrong so often?This session takes a step back and looks at the relationship between a business context and software structure using tools from the complexity sciences that help us to clarify our decision making and understand the forces that drive us to think in certain patterns. The session will take traditional methods like process and capability mapping and add a new layer of understanding that will help architects and developers avoid the mistakes of the past. The session will help us to think about where the levers are to make our designs more flexible and identify the places where we can copy from others and, most importantly, where we need to think for ourselves.

speaker

Barry O'Reilly

stage

Telekom Stage

time

11:00 - 11:45

tags

architecture, software architecture, modular monolith

Most delivery problems accumulate rather than announce themselves. We see this when cycle times stretch gradually, or parts of the codebase become zones no one wants to touch. AI tools get introduced with real promise, but their impact varies across teams in ways that are hard to explain.The usual response is a large intervention, whether it's a new process, a platform overhaul, or a transformation initiative. These generate visible movement, but they rarely generate durable stability.In this talk, we'll look at why our classic interventions fail to strengthen delivery over time, and what actually does. Using examples from AI integration, code reviews, and refactoring, we'll trace how specific, repeatable behaviors inside daily work determine whether a system gradually self-corrects or slowly accumulates fragility.You'll leave with a concrete approach to finding the smallest precise action inside workflows you already have. Specifically, we’ll be tackling change that shows up in behavior, not slides.

speaker

Marian Hartman

stage

Telekom Stage

time

12:00 - 12:45

tags

leadership, management, maintenance, TECH LEADERS, tdd, design

Every significant software design choice—whether you’re designing a bounded context, deciding on the system boundary, settling on an architectural style, selecting a complex system integration approach, and even evaluating a block of AI-generated code—has a moment where one path just feels right. But what if that powerful 'gut feeling' is actually a cognitive bias in disguise?The human mind is a powerful tool, yet it is systematically prone to errors. These errors aren't just abstract ideas; they are design flaws in our own decision-making that can lead directly to fragile architectures, ballooning technical debt, and costly rework, regardless of whether the code was human or machine-generated. Biases like the anchoring effect (getting stuck on the first idea) or the sunk cost fallacy (clinging to a failing project) are constantly shaping your software.Join us to move from a reactive, bias-driven approach to a deliberate, resilient, and ultimately more effective design process. This talk explores how cutting-edge research from behavioural economics can be applied directly to software architecture and development, with or without AI assistance.We will move beyond simply being aware of biases. We will introduce a practical, five-step checklist designed to systematically 'debias' your design choices, helping you build both better software and a better decision-making habit for all your technical work.You will learn how to:Be Decision-Ready: Recognize when Myopic Misery is rushing you into action, or when Status Quo Bias is trapping you in inaction due to cognitive load—ensuring you make choices based on strategy, not mental fatigue.Broaden the Frame: Combat Functional Fixedness and Additive Bias to uncover the elegant solutions your brain naturally ignores—breaking the cycle of solving every problem by simply adding more complexity.Seek Independent Advice: Move past Overconfidence Bias and Correlation Neglect to stop mistaking echoed opinions for independent proof, ensuring you are acting on diverse data rather than a single weak signal amplified by the group.Test Your Assumptions: Inoculate your team against the Authority Bias of AI-generated code and the Illusion of Control it fosters, replacing the dangerous comfort of "black box" certainty with rigorous stress-testing that withstands real-world chaos.Establish Simple Rules: Avoid the Law of Triviality (bikeshedding) to dramatically increase velocity, ensuring your team stops debating low-risk choices and focuses their cognitive energy on the decisions that actually stick.

speaker

Kenny (Baas) Schwegler, Evelyn van Kelle

stage

Telekom Stage

time

14:00 - 14:45

tags

architecture, design, software architecture, vital skills, architecture decision records, ai

Developers have always made implicit architectural decisions. What has changed is the speed at which those decisions get delegated to AI agents. When a developer who doesn't deeply understand the problem prompts an AI, the AI doesn't understand it either. It fills that gap with assumptions that are fluent, convincing, and invisible. We treat that confident output as authoritative and lower our scrutiny. What researchers call cognitive surrender. AI-generated code doesn't just inherit our biases. It compounds them in a reinforcement loop: biased decisions produce biased context, which produces more biased suggestions.This is not just an AI problem. It's an architecture problem that AI makes visible, and more urgent. As teams move faster with AI, centralised architecture governance becomes an even bigger bottleneck, pushing more decisions into the implicit. But AI also creates an opportunity: we can feed engineering and architectural principles forward into the software development lifecycle, earlier and more explicitly than before. That requires facilitating and coaching architecture at the team level, not reviewing output after the fact. Real practitioner stories on facilitating software architecture consistently confirm: the answer is not more control, but collaborative practices and strong engineering principles that make architecture a shared team capability.This is an interactive session. Expect to think out loud, share how you make architectural decisions today, and explore together what it takes to keep architecture intentional, explicit, and human-led in an AI-accelerated world.

speaker

Kenny (Baas) Schwegler, Evelyn van Kelle

stage

Telekom Stage

time

14:55 - 15:40

tags

architecture, artificial intelligence, software architecture

We’ve entered the era of “just add AI.” Slap a prompt box on it, ship it, call it intelligent. But the products people love don’t feel like AI demos. They feel obvious, fast, and considered. They have taste.Taste isn’t subjective fluff. It’s the difference between a streaming response that renders progressively and one that dumps text in a single repaint. It’s choosing to compose rich, interactive UI instead of defaulting to a chat window. In this code-heavy session, we’ll explore what taste actually means when building with AI: performance patterns, rendering decisions, and the product instincts that separate forgettable AI wrappers from tools people reach for every day.

speaker

Tejas Kumar

stage

Telekom Stage

time

16:00 - 16:45

tags

ai, artificial intelligence, programming

Building AI-powered customer support in fintech isn’t just about integrating ChatGPT. It requires careful risk management, continuous impact validation, and pragmatic product decisions.In this talk, I’ll share how we built and rolled out automated chat support at Wise for its 15M+ customers over the past year - evolving from simple ML classification to full conversational agents. You’ll learn how we balanced innovation with caution in a regulated environment where mistakes can have high consequences.What You’ll Learn:- Incremental delivery strategies: How to ship AI capabilities step-by-step while proving value at each stage, rather than disappearing for months to build the perfect solution- Data-driven decision making: Using metrics to validate each evolution and know when to move forward- Risk management in production: Navigating compliance reviews, managing risks, and building safety nets for when things go wrong- Build vs. Buy tradeoffs: When to partner with specialized providers and when to invest in custom solutions - and how to do both simultaneously- Making AI work for your domain: Context engineering, knowledge base design, and adapting general-purpose LLMs to specific business needsThis isn’t a story about perfect execution - it’s about pragmatic product engineering in the real world, where you need to deliver value continuously while working toward ambitious goals.

speaker

Balázs Csintalan

stage

Telekom Stage

time

16:55 - 17:40

tags

ai, product thinking, llms

What happens when you try to build digital public services using AI? Since GOV.UK was founded in 2012, multidisciplinary teams combining engineers, researchers, designers and policy people have produced world-class services in the UK. The advent of AI threatens to upend that delivery model, breaking ecosystems and business models that have enabled software to work for the public. This talk, based on direct experience in the British Government's Incubator for AI, looks beyond hype and speculation to reveal what actually happens when you try to ship more and faster with AI.

speaker

Duncan Brown

stage

Telekom Stage

time

10:30 - 11:15

tags

programming, ai, design, software development, leadership

speaker

Jeremy Edberg

stage

Telekom Stage

time

11:30 - 12:15

tags

architecture, scaling

You swapped work-toil for vigilance-toil. Watching AI closely enough that nothing goes wrong is still toil. More stressful, less interesting toil.AIs are fast enough that even rare risks happen too often. Even a small failure rate demands constant vigilance, which defeats the point. Low risk isn't enough to delegate safely. We need a known class of operations with zero risk.The exit is Careless Design: build the agent's world so careless behavior still succeeds. That's different from making AI more capable.This session maps the agency delegation model, from human-does-everything to AI-holds-operational-agency. We work through what makes each level safe: narrow tools, deterministic workflows, deliberately scoped context. We do this in ugly brownfield code, where the hazards are sharpest.#ZeroBugs has applied this to human developers for a decade. When someone makes a mistake, don't ask them to be more careful. Instead, improve the environment so that even more careless behavior would still succeed. Now it applies to agents.

speaker

Arlo Belshee

stage

Telekom Stage

time

13:45 - 14:30

tags

ai, artificial intelligence, code quality, legacy code, software development, technical excellence

Remember when one team would build software, then hand it off to another team to deploy it and get it working in production? I seem to recall we came up with better ways to deliver software. We even made up cool buzzwords like "DevOps" and "Continuous Delivery."Many years later, I see people using LLMs to iterate on building an application and treating production readiness as an afterthought. That might be fine for demos and personal projects. But if we're going to use agents to build real, business-critical software, we need to use agents to make sure the software is fit for purpose. We need to know that the software and its infrastructure performs, scales, recovers when things go wrong, and stays secure and compliant.I maintain that continuously ensuring software is production-ready as it's developed is at least as important when using agents as when we hand-code it. I'll talk about how to pull the path to production inside the agentic development flow. And I'll share why doing this kind of blew up on me the first time, and how I had to adjust my thinking to make it work.

speaker

Kief Morris

stage

Telekom Stage

time

14:50 - 15:35

As we move toward a world where coding agents do more of the work, what does that actually mean for software craft?Do we still need it? Or can we just go with the Vibes?It turns out that you are still only as fast as your codebase is clean.And one does not simply make an LLM generate code that it can also maintain.Through stories from real work with coding agents, you'll see how craft beats complexity, and why making things extremely small and verifiable is what keeps agent-generated code maintainable, and makes working with agents enjoyable.Software craft is not nostalgia. It is what makes AI-augmented development work.

speaker

Gregor Riegler

stage

Telekom Stage

time

15:45 - 16:30

As AI systems become capable of writing, modifying, and operating software autonomously, we are entering an era where code is abundant and change is continuous. But if software increasingly builds itself, what exactly are we architecting?This talk explores how the rise of autonomous development reshapes what architecture means. Traditional patterns - from microservices to API contracts - were designed for human teams working at human speed. When AI agents can generate services, refactor systems, and negotiate interfaces at machine pace, those assumptions no longer hold.We’ll examine three fundamental shifts. First, architectures must become machine-comprehensible - not just documented for humans, but structured so agents can reason about change. Second, we move from designing systems to designing guardrails: encoding intent, cost boundaries, and risk tolerances that constrain autonomous behaviour. Third, human understanding no longer scales by default; when systems evolve at machine pace, comprehension and oversight must be designed deliberately.These shifts redefine what it means to shape software. Translating strategy into machine-readable constraints, maintaining clarity amid constant change, and governing systems where authorship is shared between humans and AI become core concerns.The future isn’t codeless - it’s architecture-first. When change is automated, the stability, trust, and intent of our systems depend on how deliberately we design the environments in which they evolve.

speaker

Matthew Clark

stage

Purple Stage

time

11:00 - 11:45

tags

architecture, ai, software architecture

Building correct distributed systems takes thinking outside the box, and the fastest way to do that is to think inside a different box. One different box is "formal methods", the discipline of mathematically verifying software and systems. Formal methods teaches us to see a system through three different perspectives: the abstract specification behind the system, the environment it assumes, and the properties it should and shouldn't have. Rather than gradually learn these perspectives from months of using formal methods, we will instead learn them through a forty-ish minute conference talk.

speaker

Hillel Wayne

stage

Purple Stage

time

12:00 - 12:45

tags

architecture, tools, software architecture, scaling

Autonomous teams are an article of faith in modern software development. Give cross-functional full-stack full-lifecycle teams autonomy and they will deliver value and flow – or better value, sooner, safer, happier.But where are the boundaries of autonomy? Where does governance and policy fit in? Can a team decide their own HR practices, interactions with regulators & funding model? What about architecture, design, or organisational decisions that – by the nature of the product, not a poorly chosen architecture – must span multiple teams, or even multiple teams-of-teams? How are they made?How are autonomy and coherence balanced in a fractal way? Who decides what, when and how? And who decides who decides?Simon will provide a combination of theory – the Viable Systems Model, the Platform model ("preventing unnecessary creativity"), Socio-Technical design principles – and practical experience, as a preview to his contribution to Jon Smart's forthcoming book tentatively titled Organising for Outcomes.

speaker

Simon Rohrer

stage

Purple Stage

time

14:00 - 14:45

While senior engineers have always prioritized code health, the AI era has turned a best practice into a survival requirement. As we shift from manual coding to the role of Code Health Guardians, our primary task becomes reviewing and protecting codebases that must now survive an unprecedented commit velocity.But is being a Code Health Guardian just a full-time review job now? What happens to our own craft? How do we maintain intellectual control over the codebase without burning out or becoming the new bottleneck?In this session, you will learn:Theory-practice feedback loop: How the cycle between real understanding and practice has driven progress in the past, how generative AI threatens that loop today, and what it means for your codebase.Code review strategy: How to address the human review bottleneck without sacrificing rigor in both self-reviews and peer reviews.Unified model for code health and its practical applications: The seven causes of complexity and three distinct types of complexity problems, and how to move beyond vague "code smells" toward a rigorous, largely objective framework for evaluating and improving code health.

speaker

Artie Shevchenko

stage

Purple Stage

time

14:55 - 15:40

tags

software development, code quality, ai, hands-on, artificial intelligence

speaker

Neal Ford

stage

Purple Stage

time

16:00 - 16:45

tags

architecture, software architecture

LLMs are powerful because their behavior emerges from billions of parameters. But they are untrustworthy for the same reason: their behavior is opaque, hard to inspect, and entangled. Changing one behavior with prompt engineering or fine-tuning will also affect others in difficult-to-predict ways. For high-stakes agentic systems, we need controls that are explicit, inspectable, and decoupled from the model.This talk applies autoformalization, the process of turning natural language instructions into formal specifications, to generate a verified authorization policy for every agent you ship. We anchor intent to system identifiers (grounding), use an LLM as a candidate policy generator (generation), and apply formal analysis via policy languages (verification) to forbid non-compliant or contradictory actions before they can execute.The result is the Verification Sandwich: a three-layer architecture and open source harness that turns an agent's instructions and tools into policy-as-code that your security engineers can read and your agent hooks can enforce.

speaker

Matthew Maisel

stage

Purple Stage

time

16:55 - 17:40

tags

ai, llms

A Structured Approach to Building Scalable Systems with Event Modeling, Event Sourcing, and Agentic CodingWhat if your requirements were something you could run?Most teams play an expensive telephone game: ideas become written specs, specs become tickets, tickets become code — and somewhere along the way, the original intent gets lost. The result is systems that surprise their builders and disappoint their users.In this talk, we show a different path.By combining Event Modeling and Event Sourcing, teams can build a shared, visual understanding of a system before a single line of production code is written. The model captures behavior, decisions, and data flow in a way that everyone - engineers and business stakeholders alike - can read, challenge, and refine.But the model doesn't stop at documentation. It becomes a living specification: the single source of truth that drives code generation and acts as the foundation for agentic coding. When the model changes, the system changes with it - not the other way around.The result is a development loop where:Models don't rot — they're actively worked on, not archivedThe model is the source of truth - understood by business, engineering and managementChanges are welcome - they extend systems rather than breaking themWe'll close with a live demonstration of the full loop: from idea to visual model, from model to generated code, and back again - showing how teams can move faster, with more clarity, and far less guesswork.

speaker

Martin Dilger

stage

Purple Stage

time

10:30 - 11:15

tags

software architecture, architecture, software development

Have you seen early productivity gains from AI, only to watch them disappear under growing complexity and production incidents? You're not alone. There's a common reason. Many production systems already struggle with technical debt. When AI agents enter the development loop, that debt becomes a multiplier. Poor-quality code not only increases defects and costs. It dramatically raises AI risk by driving high breakage rates and turning promising AI agents into legacy code generators rather than genuine help.Fortunately, there's hope on the horizon. In this talk, Adam Tornhill builds on the ideas from Your Code as a Crime Scene to show how organizations can achieve both speed and quality with AI. Backed by large-scale empirical studies on AI coding and developer productivity, we separate what works from what doesn't in real-world systems. Building on these findings, we look at a practical framework for driving and sustaining AI-friendly code at scale. The AI revolution is here. Is your code ready? The evidence is already there.

speaker

Adam Tornhill

stage

Purple Stage

time

11:30 - 12:15

tags

code quality, ai, refactoring

In May 2025, a small group of engineers inside Meta's Reality Labs asked a simple question: how can AI actually help us hit our engineering goals? Seven months later we had a 400-person community, a maturity framework, and hard data on what worked: 80% time savings on specific workflows, 81% weekly tool adoption, and replicable patterns for test coverage, large-scale refactoring, custom context integration and autonomous code fixes.That was December. Since then the models have got better, I've moved to a different part of Meta, and some of the things I was confident about have aged badly. Others have held up well.I'll share the patterns that reliably delivered results, the maturity model we used to help teams assess and grow, and the leadership strategies that turned scattered experimentation into systematic adoption. I'll also talk about what we got wrong: the trust and quality problems that dominated workshop discussions, the code review bottleneck that AI-generated diffs created, and why we threw out our original metrics.

speaker

Ian Thomas

stage

Purple Stage

time

13:45 - 14:30

tags

ai, artificial intelligence, design patterns, modernization, management

Today, most neural models for code learn from code itself: sequences of tokens that capture syntax rather than computation. While this allows models to learn the shape of code, true reasoning about programs requires understanding execution and the dynamics of computation. In this talk, I’ll present a world-model approach to learning from code: one that incorporates data from program execution to implicitly predict behavior while generating code. The Code World Model (CWM) embodies this paradigm, opening new capabilities for reasoning and offering a foundation for future research and prototyping in AI-driven software systems.

speaker

Jacob Kahn

stage

Purple Stage

time

14:50 - 15:35

tags

ai, artificial intelligence

speaker

Llewellyn Falco

stage

Purple Stage

time

15:45 - 16:30

tags

agile, agile development, ai, artificial intelligence, programming

(This is an interactive session)As AI disrupts the software industry, we face a radical threshold: Who are we now? The transactional, object-oriented paradigm of work is collapsing as knowledge becomes commoditized. For many, the shift from deterministic control to agentic supervision feels like a visceral threat to professional identity: a "tug of war" between the craft we have mastered and what the future seems to demand of us. This interactive session approaches the AI crossroads as a human modeling challenge. Together, we will move beyond technical harness engineering toward Continuous Self-Comprehension: reclaiming our agency in an era increasingly shaped by autonomous agents.Join Xin for a high-intensity discovery and learning experiment built on Connection Before Content. The session flows between:Short framing momentsVisual collaborative modelingEmotional inquiry and reflectionUsing the VIEW framework (Vulnerability, Impartiality, Empathy, Wonder) as a compass, we will move past the "polished version" of ourselves to map our daily AI reality into three distinct zones:The PossiblesIdentifying high-impact use cases where AI expands our professional capability.The LovablesUncovering the deep human needs and emotions underlying our capacity to feel powerful.The UndiscussablesNaming the "scary truths", welcoming the fear, fragility and overwhelm, while staying safe in our core. Whether you are an engineer, architect, manager, coach, or designer, you will leave with practical sociotechnical tools to intentionally model hard conversations, navigate shifting roles, and the emotional complexity of the AI era.Because ultimately, we cannot sustain continuous comprehension of increasingly complex AI-built systems without the capacity to stay deeply connected to ourselves and to each other.Join us to explore conversation as the next frontier of Collaborative Modeling, and to architect a future that remains human-centered, community-based, and profoundly connected.

speaker

Xin Yao

stage

Green Stage

time

11:00 - 12:45

tags

architecture, domain-driven design, hands-on, leadership, technical debt, design, ai

AI is now part of how we build software. Dismissing its impact is no longer an option.But adopting AI doesn’t mean outsourcing thinking. You still own the code. You still own the decisions. And there is no magic prompt that replaces engineering discipline.While AI has entered the SDLC, teams often struggle to apply the rigor they’ve relied on in the past. At one extreme, we see ad-hoc “vibe coding”: fast, creative, and largely unverifiable. At the other, autonomous agent pipelines operate with limited visibility into decisions, architectural intent, or safeguards.Both approaches fail for the same reason: they attempt to scale output without first engineering control.The real shift isn’t about abandoning practices — it’s about evolving them. High-performing teams are breaking work into smaller, iterative interactions with LLMs, using structured back-and-forth during research and planning to shape outcomes before code is ever generated. This is context engineering in practice.Without explicit constraints and verification (gained through iteration and domain knowledge), we erode some of the core principles of software craftsmanship (determinism, testability, and controlled execution), leading to systems we neither trust nor fully understand. This is not constraining (verifying) the output we produce.This 90-minute hands-on session focuses on supervised and unsupervised delivery using spec-driven development and harness engineering, where developers own the process, and generation occurs at the pace you can verify. We'll discuss how to structure iterative planning, maintain control through flow-based execution, and build systems that produce verifiable, trustworthy outcomes. Ultimately, the degree of supervision is a business decision on what you're producing and what you can verify.Adopting AI is not a tooling decision. It is an engineering problem requiring explicit choices around domain knowledge, verification, control, and security.Key Takeaways:Spec-driven development allows you to define a contract between the developer and the LLM.Harness Engineering allows you to verify that the output of generated code meets your intent.Supervised and Unsupervised use of coding agents are both highly effective ways of delivering software today.There is no magic prompt. Software engineering is a creative process, best done with a human in control. The degree of supervision is directly related to your ability to verify.

speaker

Wesley Reisz

stage

Green Stage

time

14:00 - 15:40

tags

artificial intelligence, design patterns, llms, programming

Writing distributed systems that are fail-safe has always been a challenging area and many techniques have been emerged to help dealing with the large amount of problems it involves. In the past decade we’ve been using things like distributed, persistent actor systems in Scala with Akka, or durable execution platforms such as Temporal to be able to model complex, potentially long running workflows and other business logic requiring strong execution guarantees. Hardware failures, temporary outages, transient network issues, horizontal scaling of our application are all aspects that we need to plan with and in many cases explicitly deal with to make sure our user’s are not noticing any of it. The development of Golem Cloud started in 2023 with the idea that we can make this transparent; the developer writes code that deals with their business problem and is not polluted by the complex machinery to deal with all the mentioned problems. Today we can write Golem agents (not necessarily AI agents, but anything potentially stateful and long living ) in TypeScript and Rust and we get a lot of guarantees such as fault-tolerance, scaling, observability, inter-agent communication with exactly-once semantics and so on for free. In this talk I’m going to show some of these features of the latest version of Golem through code examples, explaining what Golem does behind the scenes and comparing it to how we could achieve the same guarantees on more traditional platforms.

speaker

Daniel Vigovszky

stage

Green Stage

time

16:00 - 17:40

tags

typescript, hands-on, ai

If coding with Generative AI sometimes feels brilliant and sometimes frustrating, you're not alone. This workshop walks you through a map of the patterns that make it more powerful and predictable, from first experiments to advanced techniques.We'll explore the inherent limitations of Generative AI alongside the new possibilities it creates - examining not just whathappens, but why it happens. Understanding these underlying dynamics equips you to adapt and combine patterns in powerful ways and come up with your own solutions. Real-world examples will show some of these combinations in action.You'll leave with techniques that aren't tied to any single LLM or coding agent - practical approaches you can apply immediately, as well as the mental models that keep you effective in this rapidly changing landscape.

speaker

Lada Kesseler

stage

Green Stage

time

10:30 - 12:15

tags

ai, llms, software development, technical excellence, tools

Most of us are excellent at one or two areas of our lives and quietly neglecting the rest. In this session, Veronica Lynn Clark guides you through her signature Eight Desires framework with curiosity and courage. Come ready to roll up your sleeves. Through bold imagination, unexpected insight, and writing you didn’t know you needed, you will identify the area of your life that is asking for your attention, dream without apology into what it could become, and leave with a concrete first step — and a completely new sense of what becomes possible when you are brave enough to cross the line.

speaker

Veronica Lynn Clark

stage

Green Stage

time

13:45 - 15:35

tags

unlimited potential, TECH LEADERS, self confidence, psychology, legacy code, leadership, hands-on, imposter syndrome

speaker

Márton Szabó

stage

Green Stage

time

15:45 - 16:30

tags

ai

Most data projects deliver pipelines, dashboards, or models — yet remain isolated from the broader enterprise architecture and business transformation goals of the organization. The result? Impressive technology that fails to scale, gets duplicated, or quietly fades after go-live.In this talk, we explore how to design and position data projects as first-class building blocks within enterprise architecture — turning them into catalysts for organization-wide business transformation. Drawing on real-world patterns from large corporations, we'll cover:Strategic anchoring: mapping data initiatives to business capabilities and value streamsArchitecture integration: embedding data products into the enterprise landscape using domain-driven ownership, data contracts, and composable designOperating model evolution: shifting from project to product thinking and establishing cross-functional ownershipScaling impact: using a single data project as a reference architecture that accelerates future transformation initiativesWhether you're a data engineer, software architect, or technology leader, you'll walk away with a practical framework for ensuring your next data project doesn't just solve a problem — it reshapes how the enterprise operates.

speaker

Sam Matysen

stage

Innovation Stage

time

11:00 - 11:45

When your fraud detection system must evaluate hundreds of rules per request - each potentially scanning millions of historical records - and return a verdict in under 600 milliseconds, database architecture becomes existential. This talk covers the full journey: from a single PostgreSQL RDS instance, through customer-based sharding, to a hybrid architecture where a measurement-driven router selects the optimal database for each query, to our migration to distributed YugabyteDB.

speaker

Viktor Micskó

stage

Innovation Stage

time

12:00 - 12:45

AI is a technology that democratizes wide range of knowledge and still diversity imbalance is reproduced.Globally appr. 22% of AI-relatednpositions are held by women. AI algorithms can contain inherent biases as well - how do we make sure we have the right controls? AI quickly automates administrative roles that are mostly done by women, how they can still be rather winners of the new era than losers? How women can be visible in the fields of AI? What is our responsibility?These are the key topics the accomplished panel members will talk about.

speaker

Gabriella Mátyás-Kollár, Katalin Hornyik, Rozália Miklós, József Holderith

stage

Innovation Stage

time

14:00 - 14:45

Building an AI prototype is easy; running one in production is where the bill arrives. Ivan will break down the key factors that drive the cost of AI systems in real-world use, from inference and infrastructure to the operational trade-offs that quietly define ROI. He'll also touch on the other side of the coin: what it costs companies to bring AI into their own SDLC and developer workflows. Expect concrete examples, honest numbers, and a clearer picture of where AI is actually feasible today.

speaker

Ivan Petrović

stage

Innovation Stage

time

14:55 - 15:40

What will happen at the Compass AI & Tech Summit?This panel discussion explores the latest trends shaping the future of AI/ML, product development, UX/UI, data, and engineering leadership - and how these disciplines are becoming increasingly interconnected in the AI era.Together with the experts behind Compass, we will dive into the biggest questions each track is currently facing, while uncovering the emerging patterns across the industry.More than just a trend overview, the panel offers a behind-the-scenes look into the themes and discussions attendees can expect at Compass AI & Tech Summit - straight from the people helping shape the agenda itself.

speaker

Emese Pogácsás, Richárd Román, István Szabó, Zsuzsa Kovács

stage

Innovation Stage

time

16:00 - 16:45

Radical transparency at the organizational scale is a legitimate choice. Just look at Zuckerberg logging keystrokes, or  Benioff reading your Slack DMs. A similar approach to transparency, paired with intentionally targeted interjections prioritized based on impact opportunity, also helped us find that the client’s scale-up, org doesn't need to spend 12,000 working days a year. Most AI adoption produces faster individuals, not faster organizations. The knowledge stays in people's heads and half-written docs. Agents deployed on top reproduce the same waste, just at a higher speed. The answer is the old principle applied with new infrastructure: eliminate, simplify, automate. Then standardize and operationalize what remains. Move it into skills, plugins, custom harnesses or orchestration layers and agentic swarms your systems can call.What the session covers:Process and work discovery at the human and organizational level.Ontologies, knowledge graphs, environmental and activity metadata.Spotting and cutting inefficiencies: deciding what (and who) you don't need, not just what you do. Evaluating and prioritizing what survives.Building a multi-layer, multi-speed ingest and egest memory engine, with attribution at write-time, recency decay, self-improvement loops with a Karpathy-style auto-researcher on top.Moving your knowledge base into plugins, harnesses and orchestration layers you own and control.Workforce and organization redesign: the perfect startup team, Change management: who leads the redesign and who comes with them.

speaker

Ádám Kovács, Klara Hermesz

stage

Innovation Stage

time

16:55 - 17:40

Almost four years since the release of ChatGPT, the AI conversation remains stuck between utopian hype and apocalyptic panic. Meanwhile, its actual impact is messier and more mundane: AI isn't disappearing and isn't taking your job — it is, though, changing what "doing your job" means.For every story about AI-powered 10x engineers there is another team of engineers drowning in review queues and questioning if their work matters. For every generated artifact that saves time there is a river of AI slop that someone else has to clean up, rewrite, or explain to stakeholders who don't understand why "just use AI" didn't work.The current AI challenge is clearly cultural. How do we define productivity when the metrics have changed? What does quality mean when AI can generate something that looks good enough? How do teams maintain purpose when the feedback loops that we used to build relationship and develop our skills have collapsed?In this session, we'll examine what is actually happening in organizations navigating this shift. Drawing from real cases in universities and enterprises, we will learn from places where AI adoption has forced uncomfortable conversations about process, humanity, and value in work.You'll learn:- How to adapt your SDLC when AI moves the bottleneck- Practical frameworks for having honest conversations about AI-assisted work- Why culture matters more than tooling- How organizations are rethinking career progression- Where human judgment matters most (and how to protect it)If you're tired of AI conversation that ignores the hard parts, this session will provide a practical perspective on building teams for the business and not just the demo.

speaker

Zach Pendleton

stage

Innovation Stage

time

10:30 - 11:15

What happens when every API call across a £60 billion retailer flows through your system and a single bad configuration change could take it all down?At Tesco, more than 5 billion requests per day from devices in more than 40,000 stores worldwide, from our online grocery and retail webshops, and from hundreds of internal services pass through a single platform: Inter-Service Communication (ISC). It is classified as Tier 0 because if we’re down, the whole of Tesco is down.So how do you change a system like that? Continuously, safely, and without anyone being woken up at 3 AM? How do you guarantee 99.999% availability?In this talk, we'll walk you through the production engineering practices that let a small team operate ISC with confidence:Cell-based rollouts with automated rollback. Our deployment pipeline deploys to one cell at a time, runs integration and end-to-end tests against that cell, checks canary metrics, and only proceeds to the next cell if everything passes. If any cell fails, the pipeline automatically reverts every cell to the last known-good version — no human in the loop.Dry-run validation against a real proxy. Every configuration change submitted by our users is tested against a live Envoy sidecar before it touches production. Static validation catches syntax; the dry-run catches the things static validation can't — subtle interactions between routes, TLS settings, and cluster definitions.Synthetic monitoring that is the SLI. A dedicated service continuously probes every traffic path — same-region, cross-region, cross-subscription, public through the CDN, on-prem datacentres to cloud — and those probe results are the service level indicators our SLOs are built on.Distributed, proportionally-fair rate limiting. Rate-limiting sidecars on every gateway report real-time usage to the control plane, which calculates each sidecar's fair share of the global limit and pushes it back down — adapting continuously to shifts in traffic distribution.Incident tooling built for speed. DNS-based region and cell failover, pipeline-managed deployment locks, and disaster recovery that backs up to a completely independent storage system — so recovery doesn't depend on the thing that broke.We'll also share ISC's journey: how the platform evolved from a simpler proxy layer to where it is today, what we got wrong along the way, and the organisational patterns that make Tier 0 ownership sustainable for a small team.You'll leave with concrete, transferable patterns for deploying safely, validating ruthlessly, and building the observability that lets you trust your system — whether you run a service mesh, an API gateway, or anything else that simply cannot go down.

speaker

János Csorvási, Julia Raksimowicz

stage

Innovation Stage

time

11:30 - 12:15

Most SaaS growth discussions treat acquisition, activation, retention, monetization, and referral as separate metrics. In reality, they interact as a system. A small change in one conversion point can compound through the whole lifecycle, while a seemingly important metric may have little effect on long-term outcomes.In this talk, I will show a Monte Carlo simulator for modeling a B2B SaaS as a state machine.By running many simulations across different SaaS models, we can compare which conversion points have the largest impact on growth, revenue, and customer base size. The goal is not to predict the future exactly, but to reason more clearly about leverage: where improving the product is likely to matter most.The session is aimed at builders, engineers, and product people who want a more systematic way to think about SaaS growth than funnel charts alone.

speaker

Zoltán Dávid

stage

Innovation Stage

time

13:45 - 14:30

Will AI bring a new era to mobile netoworks? Why does the industry call 6G mobile networks AI native and why are we moving in that direction? Do we use AI to build the network or we use the network to enable AI applications? What are the main challenges and what is the current state of the industry answering them?

speaker

Benedek Kovács

stage

Innovation Stage

time

14:50 - 15:35

Every agent looks like an NPC — spawned in a harness, does the job, despawned. You don't name your grep, and you shouldn't.But some agents have a human behind them, quietly running them in the real world: always-on, holding stake, acting on someone's behalf. OpenClaw just passed React's ten-year record to become the most-starred software project on GitHub in about 60 days, and a whole class of agents now runs continuously instead of dying at the end of a session. Those stopped being NPCs. They're players. And every economy in history has demanded the same thing of its players — down to the gold-farming bots in World of Warcraft, every one of which had a name: who are you?We've run this experiment before. WoW required a name for every character, then built discovery, reputation, and a real economy on top of it (the Armory was agent-discovery, shipped in 2007). The internet went from 172.217.14.206 to amazon.com, and only then did commerce show up. Agents are stuck at the IP-address stage: OpenClaw_5ff#cD33…@ixje.xyz — perfect for a machine, useless to the humans who still run the economy. It collapses to one word: "Blake."This is the dependency stack the whole agent economy is being built on — name → discovery → trust → reputation → economic agency — and we're pouring the top floors while skipping the ground one. Nobody's cracked it end-to-end yet; honestly, we don't have fully autonomous economic agents today, just the v1s. But they're arriving fast, and every one hits the same wall: you can't be an actor in an economy that can't tell who you are. The irony is the ground floor is the easy part: we've named and verified machines on the internet for thirty years. We just never did it for the agents now living on it.

speaker

Balázs Némethi

stage

Innovation Stage

time

15:45 - 16:30

Micheal Feathers feat. AVK Podcast

speaker

Michael Feathers

stage

Podcast Stage

time

11:00 - 11:45

Kent Beck feat. AVK Podcast

speaker

Kent Beck

stage

Podcast Stage

time

12:00 - 12:45

Nickolas Means feat. AVK Podcast

speaker

Nickolas Means

stage

Podcast Stage

time

14:00 - 14:45

Ian Thomas feat. AVK Podcast

speaker

Ian Thomas

stage

Podcast Stage

time

15:00 - 15:40

Evelyn van Kelle feat. AVK Podcast

speaker

Evelyn van Kelle

stage

Podcast Stage

time

16:00 - 16:45

Emese and Eszpé feat. AVK Podcast

speaker

Emese Pogácsás, Péter Szász

stage

Podcast Stage

time

11:30 - 12:15

Xin Yao feat. AVK Podcast

speaker

Xin Yao

stage

Podcast Stage

time

13:45 - 14:30

Gergely Orosz feat. AVK Podcast

speaker

Gergely Orosz

stage

Podcast Stage

time

14:50 - 15:35

What does excellent engineering management look like under AI pressure and flattening hierarchies? As technical credibility gets harder to maintain and org demands velocity and efficiency, the tech manager role is being rewritten in real time — and there's no consensus on what good looks like anymore.

speaker

Cat Swetel, Robert Ranson, Arlo Belshee, Emese Pogácsás, Péter Szász

stage

Tech Leaders' Lounge

time

14:00 - 14:45

New archetypes are reshaping what "developer" means in 2026. The product engineer owns outcomes end-to-end, talks to users, and ships without waiting for a PM. The agentic engineer orchestrates AI agents and treats prompt design as architecture. We'll dig into how to hire, motivate, retain, challenge and mentor these new kinds of developers — and whether the answers differ depending on which archetype is sitting across from you.

speaker

Gojko Adzic, Reuven Cohen, Daniel Terhorst-North, Emese Pogácsás, Péter Szász

stage

Tech Leaders' Lounge

time

10:30 - 11:15