Everyone assumes engineers are the first to adopt new tech. But when AI hype exploded, I dragged my feet.

I wasn’t sure if it was another overhyped wave or something quietly rewriting how we work. Would it make me more effective or obsolete? What would I even use it for?

This talk shares my journey from healthy skepticism to thoughtful adoption, and the real-world use cases we’ve found valuable inside a fast-moving product company. From engineering to marketing to product, I’ll walk through where AI has genuinely helped us build faster, make better decisions and where we’ve deliberately chosen not to use it.

More importantly, I’ll talk about how we stay human in the process. That includes avoiding the AI feedback loop (e.g AI writing LinkedIn posts for other AIs to comment on), designing AI-assisted experiences that feel useful, and helping teams use AI as a tool, not a crutch.

It’s a candid, practical talk for engineers and leaders figuring out where AI fits into real work not just job descriptions.

Large-language models now write boilerplate, propose tests, and even suggest architecture but those wins also introduce new failure modes, governance hurdles, and skill gaps. This session maps the concrete ways AI is upending each stage of the software-development life cycle and what it means for individual engineers and team leads. We will:

• Dissect the new workflow—treating prompts, context windows, and synthetic tests as first-class artefacts under version control.
• Show real-world patterns for validating, securing, and observably integrating AI-generated code into CI/CD without slowing delivery.
• Highlight emerging roles and competencies—from model-ops and AI governance to domain-centric “toolsmiths”—and the career paths they enable.

Attendees will leave with a practical toolkit for evolving their own processes—and their skill sets—from human-only coding to AI-augmented engineering while safeguarding quality, security, and ethical standards.

Michael Neale, creator of codename goose, an on-machine, open source AI agent built to automate your tasks explores the emerging landscape of ambient AI—agents that don't just respond to commands, but actively observe, learn, and work alongside you throughout your day. Drawing from his experience at the intersection of developer tooling and AI, Michael examines three critical shifts happening right now:

• Ambient Agent Adoption: The radical trust required when AI agents have access to everything—your code, communications, calendar, and creative process. It's not just about project-specific AI anymore; it's about agents that understand your entire digital life and can act on your behalf.
• The New Economics of Intelligence: When AI token costs can represent up to a third of a creative professional's salary, we're not just buying software, we're accessing a new kin economy, much like when we got internet access in the 90s. Michael breaks down why this economics makes sense, even at twice the price, and what it means for the future of creative work.
• Universal Agent Architecture: Why the most powerful general-purpose agents aren't dumbed-down consumer apps, but sophisticated tools originally built for developers. Computers are for computation, and the future belongs to agents that embrace this complexity rather than hide from it.

This isn't a distant future—it's happening now. Come learn how to live productively with AI that knows you better than you know yourself.

If you've ever wished there were three of you (or maybe just a quieter version who gets stuff done), this talk is for you. As Head of Engineering at Relevance AI, I’ve been quietly offloading parts of my job to agents - and somehow still kept my job.

In this session, I’ll share how I use AI to automate the boring parts, delegate without a team, and build agents that make decisions so I don’t have to. You'll get real examples, battle scars, and a practical playbook for working smarter - or at least pretending you are.

Some of the most important work in the software development lifecycle can also be some of the most boring! Keeping a codebase healthy requires a bunch of small repetitive tasks like keeping up with the breaking changes in dependency updates, or switching from an old architectural pattern to a new one in the hundreds of places that followed the old way.

Large Language Models work best with clear instructions, examples to follow, and just the right amount of context. With a bit of context engineering they can be remarkably effective in these kinds of repetitive and tedious changes - allowing you to make sweeping tech health improvements across either your gigantic monoliths or sprawling micro-services (or both if you’re really lucky). AI might be coming for our jobs, but it’s still not quite there yet, so let’s have fun giving it the boring jobs.

Everyone's shipping AI features. Nobody's talking about how to test them properly.

When AI becomes part of your application stack, traditional testing approaches break down fast. Non-deterministic outputs wreak havoc on CI pipelines, token costs spiral out of control, and teams struggle to build confidence in systems that make decisions they didn't explicitly program. Let's dive into test practices used in Envoy AI Gateway and Codename Goose. You'll see recorded response, local model serving, and LLM evaluation/benchmark techniques in non-theoretical applications.

This isn't about testing AI models themselves, but about maintaining software quality when intelligence becomes infrastructure. Whether you're integrating with external LLM APIs or running models locally, you'll walk away with concrete strategies for testing AI-powered applications that teams can implement immediately.

Think MCP servers are complex enterprise-grade infrastructure? Think again. Ben Tayor breaks down the surprisingly straightforward process of building Model Context Protocol servers that extend AI capabilities in meaningful ways—demonstrated through a real code sandbox implementation that lets LLMs safely execute code.

You'll see exactly how Ben built an MCP server that connects AI assistants to a secure WebAssembly-based code execution environment, transforming conversational AI from a text generator into a fully capable programming partner. This isn't theoretical—you'll watch real examples of Claude solving LeetCode problems and calculating prime numbers by writing and running actual code.

Ben will cover

• The MCP Mental Model — Understand how the Model Context Protocol creates a standardized bridge between AI assistants and external tools, and why this matters more than just building another API.
• From Concept to Code — Follow the actual development process of a production MCP server, including the key architectural decisions, WebAssembly integration patterns, and security considerations for sandboxed execution.
• Real-World Integration — See live demos of AI assistants using the code execution server, including debugging sessions, algorithm implementation, and the kind of collaborative coding that feels like magic but is actually just good engineering.
• The Bigger Picture — Discover how MCP servers are reshaping AI workflows, enabling everything from database connections to specialized tool integrations, and why building your own might be easier than you think.

Integrating AI capabilities into existing software systems fundamentally changes how we approach software engineering. This talk explores the engineering practices, architectural considerations, and operational challenges that development teams face when their tech stacks need to support AI-powered features.

Drawing from real-world experiences at CultureAmp and Appear, this session will cover the practical engineering challenges of preparing existing systems for AI integration:

Engineering Practice Evolution:

• How Model Context Protocols (MCPs) change service integration patterns - their security models, access scoping, API design for LLM consumption, and documentation requirements
• Adapting traditional software engineering practices for non-deterministic systems
• New testing and evaluation frameworks needed for AI-integrated applications
• Code review processes when dealing with prompt engineering and model interactions

Operational Engineering Challenges:

• Observability patterns for agentic systems - monitoring, logging, and debugging non-deterministic behaviors
• Durability and reliability engineering when dealing with external AI services
• Performance engineering considerations for latency-sensitive AI integrations
• Error handling and graceful degradation patterns

Architectural Impact:

• How existing microservices architectures adapt to support AI workflows
• Data pipeline engineering for model feeding and result processing
• Security engineering practices for AI-integrated systems

This talk focuses on the engineering discipline changes rather than product development, examining how traditional software engineering practices evolve when AI becomes a core component of your technical architecture. Attendees will learn practical strategies for evolving their engineering practices and technical systems to successfully integrate AI capabilities.

The thought of many coding agents spinning up across a mature codebase fills some engineering managers with dread, worrying about how to manage all the changes, deal with potential merge conflicts, half complete PRs, and agents going into a spiral and simply building the wrong thing. However, if you suddenly onboarded twenty grads into your development team, you would see many similar problems because the underlying systems and processes don't support a sudden influx of new developers into the codebase.

Coding agents require some specific guidance, but systems and mechanisms you implement to help scale your AI development agents can also provide additional support for your human developers when they are onboarding to a new codebase or a new part of the stack - making your dev team more resilient and productive in the long run too.

In this session, we'll cover how to implement engineering systems and processes that benefit coding agents as well as humans and make the whole team more effective and productive and the codebase more sustainable.

Stop fighting with AI tools and start architecting with them. Most engineers are stuck in prompt-and-pray mode, but the real productivity gains come from systematic workflows that turn AI from a frustrating chatbot into a strategic partner.

This talk reveals three battle-tested patterns that will fundamentally change how you build software. You'll see exactly how to compress months of learning into days, why your long ChatGPT conversations always derail (and how to fix it), and discover the "scratchpad" technique that prevents you from making the same mistakes twice.

• The Iterative Workflow — Learn why well-formed problems beat clever prompts every time, and see the strategic framework for choosing between Cursor, Claude, and Gemini based on what you're actually trying to accomplish.
• Context Management — Master the art of keeping AI conversations productive with "Clean Slate" resets, "Summary Carry-over" techniques, and the game-changing "Scratchpad" method that maintains institutional memory across projects.
• The Onboarding Accelerator — Watch a real case study of mastering Google's Agent Development Kit in record time by pointing AI at codebases and asking the right architectural questions.

This isn't about productivity hacks—it's about becoming an architect of AI-augmented workflows that amplify your engineering expertise and accelerate your entire team's capability.