"The more things change, the more they stay the same" -- Alphonse Karr, 1849 From COBOL to .COM to DevOps to AI, our industry has repeatedly promised a future where developers are no longer needed. And yet -- developers remain critical. Each wave didn’t eliminate developers—it forced them to evolve. As AI accelerates, many developers will face a hard truth: we’ve optimized for syntax instead of solving real problems. Short-term gains have come at the cost of learning the fundamentals that actually create value. AI won’t fix this—it will expose it. Design patterns, system thinking, effective communication, and quality practices didn’t go anywhere. WHAT we do hasn’t changed nearly as much as HOW we'll do it. This isn’t a talk about AI tools. It's about becoming the developer our future needs. If it appears dark, shine your light.
2026 Sessions
We’ll explore the real world tradeoffs of parallel processing through a case study of an AI pipeline that processes and analyzes large volumes of user-submitted political opinions. The system performs moderation, embedding generation, and downstream analysis using a distributed, event-driven architecture built on AWS. In this session attendees will learn how to design scalable, resilient pipelines using parallel processing while avoiding common pitfalls like rate limits, throttling, and cascading failures. They’ll leave with practical patterns for building fault-tolerant systems, balancing throughput with external constraints, and handling partial failures gracefully. We’ll break down how parallelism improves throughput and responsiveness, while also examining the less obvious challenges it introduces, such as rate limiting, back pressure, partial failures, and data consistency. While the case study uses AWS services, the architectural principles are cloud-agnostic and applicable to any distributed system handling high-throughput workloads.
"AI writes slop" is a common concern. So how can we use LLMs to not just generate good code, but to *ensure* quality? Let's explore how to create effective "guardrails" via generated tests, spec-driven development, instruction approaches, prompting techniques, context management, and more. After this session you'll have a list of novel ideas for improving your LLM interactions.
AI systems are evolving beyond chat interfaces into agents capable of taking real-world actions. But how do we safely and scalably expose tools to these systems? In this talk, we explore how to use Azure Functions as a backend for Model Context Protocol (MCP), enabling AI models to interact with real APIs, sensor systems, and business logic. Azure Functions provide a powerful and flexible backend for MCP-based AI tooling. By combining serverless computing with standardized AI protocols, developers can build scalable, intelligent systems that extend the capabilities of modern AI agents.
Your team is building features, solving technical problems, and keeping software running. Elsewhere in the organization, leaders are asking questions about priorities, investment, risk, and business goals. Those questions shape your team’s work, but how often does your team actually hear them? Understanding those conversations matters for engineers and engineering managers alike. Engineers need context to make good decisions and explain what they need. Managers must navigate the team’s daily challenges while understanding leadership’s expectations and bringing that context back to the team. Yet promotion into management often comes before exposure to the conversations that shape those expectations. For engineers considering management, we’ll discuss what to understand before making the move: how your responsibilities change, how to navigate competing priorities, and how to make decisions beyond your technical expertise. Drawing on my experience as an engineer and engineering manager, this talk explores how to connect daily engineering work with organizational goals. We’ll examine what directors, VPs, and executives need to understand, how managers can share that perspective with their teams, and how individuals can use it to make stronger recommendations for features, technical debt reduction, architectural changes, and other team needs.
What happens when a software developer decides to build a physical product? In this session, I'll share the story behind GridSmith—a modular tabletop terrain system that started as a personal frustration with existing products and evolved into a real business. Along the way, AI became much more than a coding assistant. It became a design partner, a CAD tutor, a rubber duck, a technical writer, a marketing assistant, and an endless source of ideas. We'll explore the entire journey: identifying the problem worth solving, designing hundreds of iterations of a physical product, learning OpenSCAD through AI-assisted development, optimizing for 3D printing and manufacturing, building an e-commerce website through "vibe coding," and launching a product that people can actually buy. This isn't a session about replacing developers with AI. It's about how modern AI tools dramatically lower the barrier between an idea and a finished product, allowing a single person to wear the hats of engineer, product designer, manufacturer, and entrepreneur. Whether you're a developer, maker, or simply curious about what AI can enable, you'll leave with practical insights, honest lessons learned, and hopefully the confidence to start building that idea you've been putting off.
The dump truck industry runs on handshake agreements, phone calls, and sprawling group texts. Truckers scramble to find work while contractors juggle dozens of conversations just to get trucks where they need them. The solution seemed obvious: build an Uber for dump trucks. So we did. The software worked, truckers showed up, we had insider knowledge and domain expertise. We kept improving the product and had glowing feedback. But the businesses we needed didn’t behave the way we assumed they would - and every pivot eventually ran into the same underlying problem. Using our failure as a case study, this talk looks at how engineers can identify the assumptions their software depends on, test the riskiest ones before overbuilding, and recognize when technical progress isn’t actually producing learning. As AI makes software faster and cheaper to build, knowing what deserves to be built is becoming an increasingly important engineering skill.
AI coding tools like Claude Code and OpenAI Codex are powerful amplifiers of existing developer skill. But exactly how far can you take them? Is Ralph really a useful way to write software? Spencer ran AI agents overnight, letting them tackle complex problems while he slept, for both paid projects (that netted over USD$250k in revenue!) as well as some fun side projects - and he's been doing it long before Ralph was cool. In this session, Spencer will share the lessons he learned from pushing AI coding agents to their limits. We'll discuss how to structure prompts and tasks for long-running agent sessions, how to set up your projects so agents can work autonomously, and how to review and validate AI-generated code so you're not shipping garbage. We'll also cover the practical, everyday techniques that make you a more effective AI-assisted developer. If you've been curious about Ralphing but haven't figured out how to make Ralph truly productive, this session will give you a roadmap. Come ready to learn how to put AI agents to work - even while you're off the clock.
Discover how to create shared space XR experiences utilizing the colocation features of the Meta Quest 3 XR headsets. Whether you are currently an XR developer, looking to get started, or simply curious to learn more about XR, you will leave with practical strategies for building your own dynamic shared space experiences.
The open source library you pulled in at 2 a.m.? That's a contract. The AI tool that wrote half your last sprint? It may have created code you can't claim — or can't defend. Your daily technical decisions are quietly shaping your legal reality. A patent attorney and a software developer walk into a code camp... and agree on more than you'd expect. We'll tackle the same real-world problems from both sides of the table: the IP essentials every developer should know, the open source gotchas that really bite, and how to use AI tools without giving away the code you create. Legal survival skills, minus the legalese. Come find out if you're building an asset or a liability.
AI coding assistants have changed the speed at which we write code, but they haven't changed what makes code good! In fact, they've raised the stakes. Repeated logic, unclear naming, and tangled dependencies don't just confuse new developers — they bloat the model context, confuse the LLM, and burn through your token budget while degrading the quality of every suggestion the AI makes. The result? Inconsistent, low-quality output that amplifies your existing technical debt. In this session, we'll explore why the fundamentals of software architecture — DRY principles, separation of concerns, meaningful abstractions, and testable design — aren't just good hygiene, they are essential for developing quality, sustainable software with AI. We'll look at how to scaffold AI instructions (prompt markdown files, agents, skills) so your tool follows your patterns instead of inventing its own. And we'll do live, side-by-side comparisons: the same coding task with and without architectural scaffolding, so you can see the difference for yourself. You'll leave with a portable set of LLM instruction templates you can drop into your .NET coding project today.
Tired of hearing "It works on my machine"? Dev Containers solve the pain of onboarding and dependency conflicts by treating your entire development environment as code. But getting a basic setup running is only the beginning. In this live-coding session, we will explore how to build consistent, reproducible, and highly personalized developer workspaces. We will cover the fundamentals of Dev Containers, when to use them, and how to effortlessly add tools using "Features." You will also learn how to maintain developer happiness by injecting your personal dotfiles and user-scoped extensions, without polluting the team's shared environment. Finally, we will tackle the modern workflow requirement: seamlessly integrating AI coding assistants like GitHub Copilot, Claude Code, and Opencode directly into your isolated containers across VS Code and other supported IDEs. You will leave this session ready to containerize your workflow, code from anywhere, and keep your local machine entirely clutter-free.
Many teams can build an impressive AI agent demo. The harder part is turning it into a production-ready agent that can safely use tools, reason over messy enterprise data, and earn trust from developers, users, and stakeholders. This session walks through a practical architecture for moving from prototype to production: preparing AI-ready data before model invocation, exposing tools through MCP or API-based integration layers, securing tool access with identity and authorization, adding retrieval and ranking patterns, and instrumenting agent workflows with logging, traces, evaluation, and feedback loops. Using public-safe enterprise examples from service, dealer, and quality workflows, we will break down the decisions that make agents useful beyond a chat window. Attendees will leave with a blueprint for building agents that are secure, observable, reusable, and ready for real product teams.
The right tool can make all the difference, whether in carpentry and construction or in building software. Understanding what the tools can do, and paying attention to how they work is critical in making sure we keep up with the times. AI has introduced some amazing capabilities that in the right hands can make us more productive and effective, but the rate that these tools change can leave you stranded behind. GPT and Codexes have come of age for sketching together a solution. Copilot took that to a new level by integrating this capability into our IDE's. Agents automated giving high level direction and getting features built, and now with Squad we can have coordinated agents doing this for us. How do we stay in front of the curve? That's what we'll focus on. We'll dive into the tools from a developer's focus and explore the possible.
Most enterprises will not become AI-native by replacing their core applications. They will get there by evolving them. This session presents a staged modernization path from monolithic enterprise applications to microservices and ultimately to agent-enabled workflows. It examines how service boundaries, APIs, event-driven messaging, cloud platforms, observability and CI/CD create the foundation that intelligent agents require. The session also addresses a critical architectural question: which parts of an existing system should become accessible to AI, and which deterministic business rules should remain untouched? Drawing on extensive enterprise modernization experience across financial services and retail, the session provides a practical roadmap for introducing AI into brownfield environments without creating a second architecture that becomes harder to operate than the first.
AI-assisted development has come a long way from autocomplete, further than most of us are actually using it. After a year-plus of using these tools daily on real client work, I’ve watched them go from a glorified search box to agents that can build an entire feature while I review the results from my phone. In this session we’ll make that whole climb live, with no slides full of setup screens and “here’s my results.” We’ll start from a completely empty project and build a real REST API feature end to end, using tools like Claude Code and GitHub Copilot. We’ll go one step at a time: asking the assistant questions, letting it edit code, then handing it tools to test and fix its own work. From there we’ll teach it your standards with custom skills, wire up the guardrails that keep it honest, and finally turn a team of sub-agents loose while we review the result. Whether you’ve never opened an AI assistant or you’re already running agents daily, there’s a place to jump in. You’ll walk away understanding how the pieces actually fit together, and how to start building this way on your own projects.
Behind every AI coding assistant is a surprisingly small idea: a loop that lets a language model think, call tools, and react to the results. In this intro-level session, we’ll break down how harnesses like Claude Code, OpenCode, and Pi are built, the agent loop, tool definitions, reading and editing files, running commands, and keeping the model on track. Then we’ll write a minimal coding agent together so you can see exactly where the “magic” lives. No prior AI experience required; if you can read a for-loop, you can follow along.
Software professionals operate in an environment of constant change, high expectations, and competing responsibilities. Architects, developers, leaders, parents, mentors, we often wear all the hats at once. Drawing on more than two decades as an independent consultant and technology executive, this session shares practical strategies for maintaining balance without sacrificing career momentum or personal well-being. We’ll explore managing professional timelines, protecting family commitments, investing in continuous learning, and prioritizing mental health in demanding roles. Attendees leave with concrete tools and habits they can apply immediately to reduce burnout, make better decisions, and build a sustainable long-term career in technology.
Ever wondered what it really takes to run a government-grade Kubernetes cluster in a warehouse environment with little to no internet access? This talk explores a real-world deployment of a highly secured, near-air-gapped Kubernetes platform operating far from the comforts of the cloud. With strict compliance requirements, limited connectivity, and physical infrastructure constraints, many common assumptions about “cloud-native” operations had to be rethought. We’ll walk through the architectural decisions that made this possible, including why RKE2 played a critical role in enabling secure, repeatable operations in a constrained environment. Along the way, we’ll cover image distribution, upgrades, certificate management, observability, and the operational patterns that emerge when connectivity is a luxury rather than a given. This session is aimed at engineers and architects working in regulated, edge, or high-security environments who want to understand what actually changes when Kubernetes is designed to run disconnected—and what careful planning makes possible.
Large Language Models now power accessibility tools and real‑world decision systems, yet disability bias remains one of AI’s most overlooked failures. With 1.3B people worldwide living with disabilities, the stakes are enormous. Unlike gender or racial bias, disability bias is subtle and systemic—LLMs often produce generic, overly cautious, or inaccurate responses, and frequently recommend tools that don’t match users’ needs. The root cause is a persistent “disability data desert,” where training sets lack representative disability‑related data. The result: voice assistants misinterpret non‑standard speech, mobility systems overlook wheelchair users, and assistive tech underperforms for those who need it most. This session exposes why disability bias persists, why scaling models won’t fix it, and what it takes to build truly inclusive AI. It introduces a practical framework grounded in inclusive data practices, fairness‑aware training, prompt‑level safeguards, and continuous evaluation using disability‑aware benchmarks—shifting the conversation from abstract bias metrics to real‑world impact.
Legacy applications consume 70–80% of IT budgets, yet most modernization programs stall under the weight of undocumented code, scope creep, and human bandwidth constraints. AI agents have changed that calculus. In this session, you'll see how the GitHub Copilot Modernization Agent and Azure Copilot Migration Agent work together to compress months of migration work into targeted, automated sprints — discovering dependencies, resolving breaking changes, generating upgrade PRs, and building prioritized wave plans with a human in the loop where it matters. Through a live demo on a real .NET Framework to .NET 10 scenario, you'll also see how Azure AI Foundry lets you extend these agents with custom assessment logic tuned to your organization's risk tolerance and team velocity. We'll cover where agents fall short, what guardrails to put in place, and how to structure an operating model your teams will actually adopt.
We've all seen pages of documentation that no one reads, or worse, it leads people astray. In this talk, we will challenge the conventional wisdom that "more documentation is always better" and explore why traditional documentation practices often become a liability rather than an asset. Drawing from real-world examples and hard-learned lessons, we'll demonstrate how well-intentioned documentation efforts frequently become maintenance burdens that slow teams down and mislead new contributors. This talk is for engineers and any engineering team stakeholder that has wanted a team to move faster without sacrificing clarity. Attendees will learn how to recognize when documentation helps or hurts, adopt lightweight practices that keep your team aligned, and replace stale wikis with living collaborative documentation.
The code coverage by your CI pipeline stands at 95%. Your PR looks good. Your code and its unit tests were authored by the AI coding assistant. Green all around. It's time to ship. Yet the tests aren't doing their job. There is code coverage, but no behavioral coverage – the tests run the code path without asserting the behavior and the bugs they let through are the kind that make your application crash at 2 AM. Welcome to the false-confidence crisis of AI-generated code. While there are many possible solutions out there, none matches mutation testing in effectiveness. In mutation testing, various tiny mutations are made to the codebase and the test suite is tasked with detecting them. The fact that a mutation was detected means that the test suite is missing some aspect of the code's behavior. Run mutation testing on AI-generated code and you will be surprised how often it fails even if the coverage reaches 100%. In this session, attendees will get hands-on experience with mutation testing of actual code generated by AI assistants. Attendees will observe how AI assistants generate code coverage tests that lack logical coverage; learn how to incorporate mutation testing frameworks (PITest in Java, Stryker in JavaScript/TypeScript) in your CI/CD pipeline as a quality gate step; and leave with a decision matrix to determine mutation score cutoffs that account for both completeness and pipeline performance.
What if your entire operating system, every package, every config file, every service, was just the output of a pure function? That's the actual premise behind NixOS, and once you see it, a lot of longstanding Linux pain points (conflicting dependencies, "works on my machine," upgrades that quietly break something unrelated) start to look like symptoms of a much older problem: imperative, mutable system state. This talk is a practical, entry-level introduction to NixOS through the lens of three ideas borrowed straight from functional programming: declarative configuration (you describe the system you want, not the steps to get there), immutability (your system's definition never changes in place; instead, new, versioned "generations" get created), and determinism (the same config, pinned correctly, builds the identical system anywhere, every time). We'll build a real NixOS system live and walk through instant, atomic rollbacks, the payoff that makes the whole model click. No prior NixOS or functional programming experience assumed. If you've ever used a package manager and wondered why it has to be this way, this talk is for you. You'll leave with a clear, accurate mental model of what NixOS actually is, and whether it's worth exploring for your own machines.
So here I am, having spent the majority of my life becoming a pretty good programmer, and now AI has changed everything. In this talk I want to look at our relationship with this new tech, how it's impacting our careers, and the way we think of ourselves.
Learn about the best tools you can use to make your Python development better. In this tutorial, you will learn about the following: - Python linters - Python code formatters - Python type checkers - Dead code scanners - and more! This tutorial is great for beginners and intermediate developers who want to improve their development experience.
Software is as close as humans are ever going to come to actual magic. You type arcane incantations using cryptic symbols, crafting messages incomprehensible to most mortals and communicating them to vast, unknowable systems, to be executed blindly by idiot machine gods who follow our instructions to the very character. We're an elite class of human, chosen through intense courses of secluded study, or simply by the winds of chance, to engage with this symbolic and mystic realm. But while we're comparing ourselves to wizards, witches, and sorcerers, we're actually leaving one of their most powerful tools on the table: rituals. Let's learn what our brain does when we do an activity repeatedly, with other humans, or simply by ourselves. You'll learn the difference between a ritual and a routine, you'll discover why ritual practices are an important part of being a group, and you'll get an overview of when, where, and how to employ these powerful tools. You'll complete your magical arsenal, and you'll never look at a retrospective the same way again.
We can't develop locally like it's 2021. AI coding agents have evolved from simple tab-completion into autonomous operators with shell access and deep reach into our broader engineering ecosystems, spanning local environments, Docker containers, CI/CD pipelines, and cloud tools like Figma and Google Drive. Agentic coding isn't a "free upgrade", it introduces serious security risks and host machine exposure. Protecting secrets in your Git history is no longer sufficient, we must now safeguard our local machines and connected infrastructure from the agents themselves. In this session, we will explore practical strategies for sandboxing local AI workflows to enforce strict project boundaries and prevent unauthorized system changes. We will also demonstrate how to provision tightly scoped, temporary permissions across your broader toolchain, ensuring your agents can interact with your ecosystem without holding the keys to the kingdom.
Learn essential techniques for implementing authorization in custom MCP server deployments. We’ll explore configuration approaches for authentication, role-based access patterns, and security boundaries between AI clients and your custom servers. Practical examples demonstrate how to build robust authorization layers that protect sensitive resources while maintaining system performance.
Why do some teams "click" while others clash? It usually comes down to the unwritten rules. This talk is an interactive deep dive into the art of the Team Charter. I’ll share my personal methodology for aligning diverse personalities into a cohesive unit. We’ll discuss how to facilitate honest conversations about working styles and how to bake accountability directly into your team’s DNA. Come ready to participate, reflect, and walk away with a toolkit to transform your team's culture.
I've wrote a GHA that turns a Terraform Plan into a collapsible Markdown file with diff highlighting for the changes. This talk will be about why problem the team faced at the beginning, the problem we're trying to solve, where we ended up, and how this can be taken further. There will also be a brief introduction of Terraform and the lessons learnt, including Signal vs Noise in the modern SDLC.
Many teams leverage infrastructure as code but don't test it. Learn how to test your infrastructure before you break production. I'll cover Terraform and CloudFormation testing tools—from linting to integration tests—with live demos including Test-Driven Infrastructure (TDI).
I've been working with organizations large and small on how to adopt Agentic Coding tools and techniques. While doing so, I've seen the same types of mistakes (both technical, people, and process) that pop up over and over again. In this talk, I'll give practical tips around optimizing your harness, skills you need to be leveraging, and more while also avoiding running up huge bills. Be ready for interactive live demos beyond just watching the tool "Flibbertigibbeting..." Whether you're deep into your Agentic Coding journey or just getting started, you'll walk away with practical guidance you can apply immediately back at work. And maybe most importantly, you'll be able to answer the question your boss asks you on Monday: "So what'd you learn at the conference?"
Both major parties run their field operations on data platforms that cost five figures and require committee approval to touch. Independents, third-party candidates, and local challengers are structurally locked out — not because the data is secret, but because assembling it was expensive. It isn't anymore. This is the architecture of a statewide political data warehouse built entirely from public record on a single small cloud box: 3.1 million campaign contributions, 2 million FEC records, 627,000 precinct-level results, county parcels with assessed value and residency, census geography, all joinable. Postgres/PostGIS, Docker Compose, Caddy, Metabase — no exotic stack, no funding round. We'll walk the real design decisions and the constraint that drove every one of them: a citizen must be able to run this on a hobby budget.
The software industry is obsessed with AI-driven development, yet we are witnessing a divergence in how we define "architecture." Traditionally, architecture focused on the structural integrity and long-term viability of the system itself. Today, a second, emerging layer has become equally vital, a well-orchestrated AI architecture designed to govern the specialized agents and workflows that generate our code. As tools like Claude Code and Copilot become permanent fixtures in our lifecycle, we see the rise of a new technical debt, a steady accumulation of functional code that lacks cohesive vision. This happens because AI often defaults to "average" solutions, ignoring the unique paradigms of a specific codebase. While AI provides the output, humans must still own the architectural outcome. To build software that lasts, we must master both domains. We must stop treating AI as a replacement for architectural thinking and start treating the AI environment as an architectural challenge of its own. If we cannot manage the deterministic systems we already have, we cannot hope to find success in an orchestration of non-deterministic agents. This session moves beyond simple code generation to address the fundamental responsibility of the modern developer. We will explore how to build a robust development context by moving from traditional system blueprints to a sophisticated AI architecture using custom agents, specialized skills, and other context management tools. Attendees will learn practical strategies to ensure AI remains a disciplined collaborator that respects system design rather than a source of decay. By shifting our focus from writing lines to curating the architecture of our AI agents, we can accelerate development while strengthening the structural integrity of our software foundations.
AI agents are getting good at taking action. The hard part isn't making them capable, it's knowing when to make them stop. In this talk we'll walk through the full spectrum of human-in-the-loop patterns, from lightweight inline confirmations to out-of-band permission gates to handing your agent a wallet with real money in it and more. Each pattern fits a different level of consequence, and knowing which to reach for is what separates demo agents from production ones. We'll cover the honest tradeoffs of latency, user experience, and trust so you can make the right call for your specific use case. The entire talk is built around various live demos that escalate in stakes with every step. You'll leave with a mental model and working reference architecture you can apply the same day.
C# has been in existence for more than 20 years. In recent history, the number of features and changes have substantially increased, thereby allowing C# developers to write applications with new techniques and approaches. In this session, I'll cover a number of these language improvements. I'll demonstrate how these features can enhance code bases with concision and performance. If you've coded in C# for a while, and you're interested in updating your comprehension of the language, this session is for you!