Confirmed sessions.

As AI transforms business operations and drives economic growth, a critical question remains unanswered: How do we ensure its benefits are shared equitably while minimizing harm? This session will challenge leaders to expand their perspective beyond conventional AI metrics like efficiency gains, cost savings, and productivity, to include social impact as a vital measure of success. Participants will learn why conventional responsible AI principles, while important, fall short without frameworks that meaningfully center communities, lived experience, and long-term outcomes. The session will provide practical strategies for leaders to address these shortcomings, specifically integrating social impact considerations into AI strategy and project success metrics. Attendees will leave equipped with tools and recommendations to build AI strategies that strive to benefit everyone.

We'll dig into Burea of Labor Statistics, National Bureau of Economic Research and other data to explore the bull and bear cases across industries ranging from law, medicine, software and finance. We'll also look at AI as a strain of Digital Taylorism and AI's role in the erosion of seniority pipeline.

Every agent query chains multiple LLM calls with retries. We measured the actual carbon cost of our agent fleet and it was shocking. This session covers the uncomfortable truth about agent energy economics, why observability multiplies inference spend, and the framework for deciding if an agent's business value justifies its environmental footprint.

In our continuous effort as engineers to find the fastest and most effective solution, it's tempting to assume the latest multimodal LLM with a well-crafted prompt can solve almost anything. So how come the technology that often blows our minds can fail on seemingly basic tasks, and how can we extend its limits? In this talk, I'll present a case study of building "The Evaluator," a production system for image-text matching, and show how a deceptively simple binary question ‘does this sentence match this image?’ resisted our best single-prompt solutions even with the largest models. Through systematic experimentation, we found that task decomposition dramatically outperformed monolithic approaches: by breaking the matching problem into specialized sub-tasks - entity matching, semantic alignment, visual interest, and temporal alignment - and orchestrating multiple models into a single pipeline, we achieved significant gains in both accuracy and operational efficiency.

I built a system that ships software with no human in the loop and no one reading the code. Here's how it works, and why it isn't slop. Intent comes in as an issue. An autonomous pipeline moves it through the stages a careful engineer would: design, tests first, build, review, merge. No human reviews the diff. What makes it safe isn't better code generation, it's everything wrapped around it. I'll walk the scaffolding: how tests and standards become the spec, so "working" is defined before any code exists; how quality is enforced structurally, not by a reviewer's attention; how it reviews itself adversarially, since a fluent machine convinces even when wrong; and the hard limits that bound a bad run. Plus the night it failed anyway. The takeaway: when code is nearly free, the engineering moves out of the typing and into the structure that decides what ships. That's the part you actually build.

Every software team faces pressure to ship faster without breaking things. When your company has real security concerns and skeptical leadership, "just turn on an AI coding tool" isn't a strategy. This session walks through a structured, phased pilot of OpenAI Codex focused on generating missing unit tests. Eight weeks in, cycle time on test writing dropped 19% median. You'll see how we built the ROI case for skeptical leadership, addressed security and compliance requirements before developers touched the tool, and why unit tests were the right first use case for managing risk. We'll cover how we designed pilot phases to generate visible evidence of responsible governance: documented guardrails, weekly retrospectives, and team-developed prompting best practices. Attendees leave with a reusable framework whether you're a developer wondering if AI tools are worth it, a manager building the internal case, or a technical leader navigating governance without killing the initiative.

This practitioner session shares lessons from 300+ AI-assisted development sessions, 19k+ messages, 3k+ commits, and 30+ repositories. The core finding: AI agents became reliable only when we taught them the same engineering discipline we teach humans — clean code, SOLID, TDD, micro-commits, small classes, review expectations, and fast feedback loops. We’ll show how vague prompts failed, why binary HARD BLOCK rules worked, and how version-controlled AI skills turned human coaching practices into reusable guardrails. We’ll also cover context handoffs, independent verification, and cost-tiered model use: stronger models for planning and Haiku for bounded coding once standards and checks were in place. Attendees will leave with concrete patterns they can try immediately: converting vague expectations into AI skills, replacing soft prompts with HARD BLOCK rules, separating coding from verification, and using stronger models for planning while cheaper models handle bounded work.

Generative AI is spreading through organizations faster than any technology in recent memory. Employees are experimenting, executives are investing, and new use cases emerge daily. But while adopting AI is easy, integrating it into the way your organization makes decisions, manages risk, and creates value is much harder. Drawing on more than a decade advising executive teams on digital transformation, Dave Todaro explores why organizations struggle to adopt disruptive technologies—and how AI is exposing those challenges faster than ever. Attendees will learn a practical framework for aligning leadership, enabling responsible experimentation, and creating the conditions for AI to deliver lasting business value. Key takeaways • Why AI adoption is primarily a leadership challenge. • Guardrails that accelerate rather than slow innovation. • A practical framework for scaling AI responsibly.

Most AI applications begin with tightly coupled tools and quickly grow into complex agentic systems that are difficult to scale, maintain, and evolve. The Model Context Protocol (MCP) introduces a standard contract between AI applications and external capabilities, but understanding where MCP fits and where it doesn't is equally important. In this session, I'll share lessons from building production MCP servers and agentic platforms, explain how to decide whether your use case needs an MCP server, an agent, or both, and demonstrate how a well-designed MCP server enables reusable, discoverable, and composable AI capabilities. Through architecture patterns, practical trade-offs, and a live demo, attendees will leave with a clear mental model for designing scalable AI systems and making informed implementation decisions instead of simply adopting MCP because it's new.

Your AI agent has access to your database, your APIs, and your users' data. But would you give a new hire admin credentials on day one? We do this with AI agents constantly Guide dog training programs solved this problem decades ago. A guide dog doesn't get to navigate traffic until it's mastered basic commands. It doesn't work unsupervised until it's proven reliable across thousands of scenarios. And critically, it's trained in "intelligent disobedience" - knowing when to refuse a direct command because following it would cause harm I'll introduce the Progressive Trust Framework - a practical approach to AI agent deployment. You'll learn how to implement graduated permission systems where agents earn expanded access through demonstrated reliability. We'll explore the "3D's" testing methodology (Distance, Duration, Distraction) for validating agent behaviour before promotion. And we'll tackle the hardest problem: training agents that refuse harmful requests without becoming paranoid

Most product orgs were not designed for speed. They were designed around the assumption that shipping software is slow, expensive, and risky—and nearly every layer of the org chart exists to manage that slowness. Program managers synchronize work split across team boundaries. Specialist functions run their own backlogs and SLAs. Product leadership plans in quarters - the natural rhythm of slow work. AI-driven delivery breaks these assumptions. When a team ships in a day what used to take six weeks, the coordination meeting takes longer than the work it was meant to coordinate. The specialist intake queue becomes the bottleneck. The annual roadmap is wrong by the second week. This talk makes the argument that most orgs are avoiding: if we're serious about what AI does to delivery speed, we have to be equally serious about what it does to everything surrounding delivery. Drawing on my experience helping orgs make the shift, I'll lay out the shape of the new product org.

The next wave of AI development will not be defined by better autocomplete or another layer of chat interfaces. It will be defined by agentic systems that can plan, execute, inspect their own work, call tools safely, collaborate with humans, and carry state across real workflows. This talk looks at where AI development is headed over the next 12-24 months: from single-purpose copilots to coordinated agent systems embedded in delivery pipelines, operations, product experiences, and internal platforms. We’ll separate near-term reality from conference-room science fiction, covering the patterns that are already starting to work. It will also cover real world examples from within Meijer and other organizations and how they're looking at the future. The winners will not be the teams that “add AI” everywhere. They’ll be the teams that redesign software work around trustworthy delegation, measurable outcomes, and systems that know when to act, when to ask, and when to stop.

AI usage is climbing fast, and most teams have no idea what it's costing them or where the waste is. The reflex is to treat efficiency as the model vendor's problem. That worked when an AI feature was a single API call. It doesn't work now that we're composing platforms, MCP servers, RAG backends, and agentic pipelines we own. This talk reframes AI cost as a behavioral problem, not a vendor problem. We'll walk concrete, measurable techniques: model routing, right-sizing context, caching and batching, closing the capability-overhang gap, and agentic decomposition as a savings multiplier, plus the metrics to know whether any of it works. This session is for software architects, developers, and technical leaders who want to rein in AI spend without sacrificing quality. You'll leave able to spot where your pipelines waste tokens, apply specific techniques to cut that waste, and measure whether it worked.