Sessions

Agents get a lot more useful when they can finish the job without you sitting in the middle of every step. The missing piece is usually the loop: act, observe, verify, and only stop when the work is actually done.

In this talk, I’ll show how to close that agentic loop. We’ll look at how agents can verify their own work, how good system design shows up in the diffs they produce, and which primitives you can compose so they operate with real autonomy. I’ll also share how Kody MCP fits into this picture: searchable capabilities, sandboxed execution, memory, and the surfaces agents need to check their work before they hand it back to you.

You’ll leave with a practical model for widening the loop—trading a bit of compute for a lot less babysitting—so your agents ship work you’re willing to trust.

Most people working in AI feel behind. It seems like every day they open their email and find yet another model release or tool to learn, feel stressed from constant change and chaos, and often fear for the future of their jobs.

This talk is about staying current without making yourself miserable in the process.

We’ll start with the practical side: what’s worth learning vs. what can be safely skipped, and how to develop a consistent learning plan that helps you keep your skills sharp without becoming overwhelmed.

Then we turn to the mindset side, which might matter even more. We’ll discuss how to handle common blockers like imposter syndrome, procrastination, and guilt, to keep you advancing your career over the long term from a place of curiosity and enjoyment instead of fear and stress.

Marina Wyss has coached more than 200 career changers into AI roles, and has seen first hand that the people who build durable careers are the ones who found a relationship with this field they can actually sustain.

Attendees will leave with a concrete weekly learning system and a healthier way to measure progress that doesn’t depend on keeping up with everything.

AI coding agents are changing what it feels like to be a software engineer. For a lot of us, that’s challenging our sense of craftsmanship. If agents are writing the code, do we lose the joy of building?

I don’t think so. The building moves up a layer.

In this talk, I’ll share how I found that familiar engineering flow state again. Not by writing every line myself, but by designing agentic systems that still require the engineering principles we value: systems thinking, decomposition, separation of concerns, state management, etc.

The tools are different now, but the engineering discipline is still there. We’ll walk through how to apply the engineering muscles you already have to a new set of building blocks.

If you’ve been wondering where your value goes in an AI native world, this talk will help you see that it hasn’t disappeared. It’s now at the system level.

When AI Disappears, You’re Doing It Right

The best AI workflows are not the ones that make engineers think about AI more. They are the ones that let engineers focus on the work again.

This talk explores how AI can become a natural part of software development rather than another source of friction.
Using examples from real world issues, and your even learn about the concept of tools becoming “ready-to-hand,” – (i.e disappear) we’ll look at how mature AI use actually feels.

Attendees will learn how to distinguish between AI that reduces friction and AI that merely adds novelty, when to let AI disappear into the workflow, and when engineering judgment needs to bring the tool back into focus.

What an agent can do is capped by infrastructure, not model quality. Harnesses like Claude Code and Codex stay narrow, so the hard parts of running agents in a real SDLC (permissions, CI, code changes, cross-session memory) get reinvented inside every org. A meta-layer is forming, just like Next.js formed around React. This talk defines the meta-harness and shows how it makes agents more autonomous.

The era of “just throw an LLM at it” is ending. As AI companies raise prices, move toward IPOs, and optimize for profitability, teams are being forced to rethink how they build AI-powered products. Cost is no longer just an infrastructure concern; it is now a product, architecture, and business strategy problem.

In this session, we’ll explore how to design AI systems that are useful, reliable, and cost-effective. We’ll look at where costs actually come from, including model calls, context size, retrieval, orchestration, evaluation, and unnecessary agentic complexity. We’ll discuss practical patterns for reducing spend: using smaller models where possible, caching, routing, prompt and context optimization, open-source models, hybrid architectures, and moving away from vendor lock-in.

Attendees will leave with a framework for deciding when to use proprietary APIs, when to move to open-source models, and how to evaluate whether an AI feature is delivering real ROI.

AI shifts the bottleneck of software engineering from syntax to intent. If you don’t spend time explicitly defining your data models, boundary lines, and tech stack (like pairing Claude with a deterministic backend framework), you are just accelerating how fast you build technical debt.

The way we build with AI has changed quickly, and every few months a new term seems to appear: prompt engineering, context engineering, harness engineering, loop engineering. It is easy to dismiss these names as hype. But behind each one is a real shift in what we build and how we build it.
This talk tells the story of that shift.

Prompt engineering focused on how we ask the model. Context engineering focused on giving the model the right information, in the right shape, at the right time. Harness engineering focused on the system that lets the model act reliably. Loop engineering focuses on autonomous systems that keep finding, scheduling, delegating, and reviewing work over time.

The point is not that each new term replaces the previous one. They build on each other.
By understanding this evolution, we get a clearer picture of what modern AI engineering really means: designing systems, not just prompts.

AI is giving every team new capabilities. People can analyze information, create prototypes, automate tasks, and build solutions for themselves. Many feel more powerful than ever.

For engineers, that same shift can feel destabilizing. A leader recently told me that employee NPS was climbing across the company while falling dramatically within engineering. His engineers were asking a difficult question: if producing code becomes faster and more accessible, where do I create value?
The answer is an expanded role.

The industry moved from specialized frontend and backend roles toward full stack engineering. AI is driving the next evolution: the product engineer. Product engineers understand users, business models, workflows, constraints, and desired outcomes. They find the right problems, determine where technology can create leverage, and remain accountable for whether the solution works.

This talk will show developers how to evaluate real workflows alongside business partners, recognize valuable opportunities, and transform technical possibility into measurable impact. Your new stack includes the customer, the workflow, the product, and the business.

This talk covers how we designed evals for Uber’s food enhancement agent—which edits food photography to better present dishes for smaller, independent Uber Eats merchants—along with the pitfalls and lessons learned along the way.

The problem is uniquely hard: we must stay faithful to the original dish, preserve each merchant’s brand and packaging, and avoid homogenizing the marketplace—all without an existing playbook for multimodal evals in a narrow domain. We’ll dig into what we learned navigating reward hacking, where the agent figured out how to game the eval loop, and how we built a closed feedback loop incorporating offline and online signals for continuous improvement—all while balancing creativity against rigid safety guardrails at scale.

If you’re an ML or applied AI practitioner working on multimodal systems, agentic pipelines, or eval design—especially building generative features under tight safety or quality constraints—you’ll walk away with practical strategies for designing multimodal evals in a narrow domain, recognizing and countering reward hacking, and building offline/online feedback loops that keep a generative agent improving in production.

Python-based approach to evaluating nondeterministic agent workflows and comparing harness changes through controlled experiments. Using generic examples, we’ll look at how to test changes to prompts, tools, and architecture, catch regressions, and build confidence that a change actually improves quality.

Agents have more and more authority these days: authority to act on our behalf or their OWN behalf. They can drop databases, push to production, sign contracts, exchange sensitive information, control computers, and much more. Giving them access is easy: API keys and –dangerously-skip-permissions are attractive options when we need agents to be useful and autonomous. In this talk, I’ll demo the power of an agent brandishing API keys. Then I’ll show how pre-existing open standards can give agents identity AND securely grant (or deny) access on every single tool call, without chaining you to your desk deciding whether to click “Allow” for every sensitive action.

See how the GitHub Copilot app brings agent-driven development into a single desktop application, helping you move from ideas to working code while staying in control of the process.

In this 1-hour, demo-driven session, you’ll explore the app’s key capabilities, including agent sessions, isolated workspaces, and different ways to guide AI agents through development tasks. You’ll see how GitHub Copilot can help plan and implement features, modify code, run tests, preview changes, and review results.

Along the way, you’ll discover practical techniques for providing context, supervising agent workflows, and validating AI-generated code. You’ll leave with a better understanding of how the GitHub Copilot app fits into everyday development, how to get started using it in your own projects, and how it can significantly boost your productivity.

See how the GitHub Copilot app brings agent-driven development into a single desktop application, helping you move from ideas to working code while staying in control of the process.

In this 1-hour, demo-driven session, you’ll explore the app’s key capabilities, including agent sessions, isolated workspaces, and different ways to guide AI agents through development tasks. You’ll see how GitHub Copilot can help plan and implement features, modify code, run tests, preview changes, and review results.

Along the way, you’ll discover practical techniques for providing context, supervising agent workflows, and validating AI-generated code. You’ll leave with a better understanding of how the GitHub Copilot app fits into everyday development, how to get started using it in your own projects, and how it can significantly boost your productivity.

Ready to move beyond AI chat and build an agent that can actually reason, use tools, and take action?

In this hands-on lab, you’ll build an AI agent using Microsoft Foundry and Microsoft Agent Framework (MAF) for Python, exploring the core engineering patterns behind agentic applications. You’ll see how models, instructions, tools, and context come together in an agent loop where the system can reason about a request, decide what action to take, execute a tool, and use the result as new context.

Then you’ll put those concepts into practice. Starting in Microsoft Foundry, you’ll create your agent, connect it to a cupcake shop MCP server, define its behavior through instructions, and put it to the test with the ultimate mission:“Order me a vanilla cupcake.” 🧁 From there, you’ll extend the code and explore how the same patterns can evolve toward production-ready agents with observability, evaluation, governance, and continuous iteration.

Come ready to code. Leave having built an agent that doesn’t just answer questions, it takes action.

Beyond the One-Off: Building Repeatable Modernization Systems with GitHub Copilot

AI can help modernize an application. But getting one successful result from one carefully managed demo is very different from building a modernization approach that works repeatedly across repositories, languages, teams, and application portfolios.

In this technical session, we’ll explore how to turn AI-assisted modernization from a collection of one-off prompts into a repeatable engineering system. Using GitHub Copilot, we’ll walk through a governed lifecycle for assessing applications, generating reviewable plans, executing transformations, validating results, and capturing successful patterns for reuse.

Along the way, we’ll examine the practical design choices that determine whether a modernization solution is affordable and reliable: where deterministic tools should complement agents, how to control context and model costs, how to encode organizational standards, and where developers must remain in the loop. A live demonstration will show these ideas applied to an existing application, but the real focus is the reusable architecture around the demo.

Attendees will leave with a framework for designing modernization workflows that can move beyond a successful pilot and become a process their organization can confidently run again.

This session is a presentation due to the time constraint it is designed not to be a follow along rather a watch and learn.

The Agent Interface Is Changing: From Chat to Canvas

Chat made AI agents accessible, but it also compressed complex work into a narrow stream of prompts and responses. As agents take on longer-running, multi-step tasks, we need better ways to understand what they are doing, inspect their decisions, provide direction, and intervene when necessary.

This interactive session explores a new model for working with agents: the canvas as a shared control surface. Instead of treating an agent as a chatbot that disappears between prompts, a canvas can make the work visible through persistent context, application structure, plans, progress, actions, and results.

We’ll begin by examining how our relationship with agents is changing and why chat alone can become limiting for more complex workflows. Then attendees will use GitHub Copilot to create and customize their own canvas experience around a problem they choose. Rather than following one rigid lab, participants will experiment with how information, controls, and agent actions should be presented to make collaboration clearer and more effective.

Attendees will leave with a working prototype and a new mental model for designing agent experiences that are easier to understand, direct, and trust.

This session is exploratory. Attendees are not required to follow along but have the option to experiment with the Github Copilot App experience if they would like. I will be working live as well for those who just want to watch to follow along