Schedule
Times below are shown in your local browsers time zone.
2026-12-04T09:00:00.000Z
2026-12-04T11:00:00.000Z
2026-12-04T13:00:00.000Z
2026-12-04T14:00:00.000Z
2026-12-04T15:00:00.000Z
2026-12-04T16:00:00.000Z
2026-12-04T17:00:00.000Z
2026-12-04T18:00:00.000Z
2026-12-04T19:00:00.000Z
AI Coding Summit Track (Main Hall)
2026-12-04T13:00:00.000Z
Opening Ceremony
2026-12-04T13:10:00.000Z
I Built a Software Factory. I Barely Used It. Here's How I Fixed It.
Juri Strumpflohner
I built a software factory: a Kanban board where dragging a card starts an agent, tasks that unblock each other as they finish, agents with their own roles and prompts, and an adversarial reviewer that goes through the code before I ever see it. It worked. I barely used it.The problem wasn't the factory, it was that I kept working the way I always had: sitting with an agent, pushing it forward, jumping to the next one, course correcting. Everything interactive.
2026-12-04T13:30:00.000Z
QnA with Juri Strumpflohner
2026-12-04T13:45:00.000Z
Continuous Performance Engineering in the LLM Era
Halil Emre Özen
AI has made writing code cheaper, but the hardware doesn’t get any cheaper.I build React apps used worldwide, many running inside WebViews on affordable Android phones. These devices often represent the slowest 10% of user experiences. Even when all CI checks pass, performance issues can still slip through review.AI has also made another part of this process harder. We can release more code, but reviewers still have the same time.
2026-12-04T14:05:00.000Z
QnA with Halil Emre Özen
2026-12-04T14:15:00.000Z
Break
2026-12-04T14:45:00.000Z
Agentic AI Can Modernize It. But can you Prove it Did?
Julia Kordick
Application modernization has always been hard. The hardest cases combine decades of complexity with missing knowledge, proprietary technology, hardware dependencies, unclear requirements, and systems that cannot simply be switched off. Agentic AI gives us a new chance to make these projects technically and economically viable. It can reconstruct knowledge, explore unfamiliar systems, and support modernization at a previously unrealistic scale.
2026-12-04T15:05:00.000Z
QnA with Julia Kordick
2026-12-04T15:20:00.000Z
From Vibe Coding to Vibe Engineering
Kitze
2026-12-04T15:40:00.000Z
QnA with Kitze
2026-12-04T15:50:00.000Z
Break
2026-12-04T16:00:00.000Z
Goodbye Slop; Welcome Determinism
David Khourshid
Vibe coding feels productive until you have to maintain it. Behind the agent "thinking..." you ignore and the code you never opened lies a growing pile of wasted tokens, nondeterministic behavior, and compounding errors hiding in plain sight.This talk pushes back on the status quo: elaborate agent architectures, "prompting astrology", overnight automation loops burning through context windows and credit cards. We'll look at why determinism, state machines, and explicit guardrails aren't "old-school"... they're the only sustainable way forward.We'll look at why vibe coding compounds technical debt faster than any era before it, and how modeling behavior explicitly lets you ship AI features you actually understand, maintain, and trust.
2026-12-04T16:20:00.000Z
QnA with David Khourshid
2026-12-04T16:30:00.000Z
The Code Isn't Precious: What Every Staff Engineer Figured Out That You Haven't Yet
Scott Batson
The engineers who make it to staff level aren't the ones who wrote the cleverest code. They're the ones who figured out that code was never the point.Most of us learn this too late — after burning hours on solutions no one asked for, defending implementations no one remembers, wondering why technical excellence isn't translating into career growth.Agentic AI just made this lesson impossible to ignore. But for engineers feeling anxious about that, there's good news: what actually drives growth at every level — senior, staff, and beyond — has always been more human than technical. How you communicate.
2026-12-04T16:50:00.000Z
QnA with Scott Batson
2026-12-04T17:00:00.000Z
Score, Review, Spec: Multi-Agent Quality Gates in CI
Dipanshu Gupta
We had more incoming requirements than our team could review, so we built a multi-agent pipeline in CI that takes raw requirements and turns them into reviewed, scored, spec-ready work items. Each requirement gets scored across five dimensions with a hard pass threshold. The ones that pass go through four parallel AI reviewers covering Feasibility, Testability, Scope, and Architecture. Each reviewer writes its findings back to Jira as markdown that engineers actually pick up and use.
2026-12-04T17:20:00.000Z
QnA with Dipanshu Gupta
2026-12-04T17:30:00.000Z
Talk TBA
2026-12-04T17:50:00.000Z
QnA with TBA
2026-12-04T18:00:00.000Z
A Test That Passes for the Wrong Reason: Reliability for AI-Assisted Conformance Testing
Lorenzo Dal Col
A test that passes for the wrong reason is the worst failure in test code: it certifies a broken GPU driver and nothing alarms. I maintain the Khronos Vulkan Conformance Test Suite and run AI coding agents on it every day. This talk is the grading discipline that keeps that work honest: every agent result checked against a human-reviewed reference, so I can tell a correct fix from a lucky-looking one before it ships.
2026-12-04T18:20:00.000Z
QnA with Lorenzo Dal Col
2026-12-04T18:30:00.000Z
Why Agents Ignore Your Rules
Filip Hric
Every repo has them now: CLAUDE.md, AGENTS.md, a folder of markdown rule files written to steer the AI. Write the rule once, get the code you want. Except these files are advisory, not enforced, as every major vendor says so in their own docs. The research backs it up.
2026-12-04T18:50:00.000Z
QnA with Filip Hric
2026-12-04T19:00:00.000Z
Closing Ceremony
AI Coding Summit Track (Hall 2)
2026-12-04T13:00:00.000Z
Opening Ceremony
2026-12-04T13:10:00.000Z
Lightning Talks
• Stop Generating, Start Deciding —
Maxim Salnikov
• Your Old PRs Are Your Coding Standards —
Eddy Vinck
2026-12-04T13:45:00.000Z
The Dirty Secret Behind AI Agents: Build One in 80 Lines of Code
Sylwia Laskowska
AI agents seem complicated. But once you look under the hood, they're built from a few simple ideas.In this talk, I'll use a real AI agent to show how its core loop fits in around 80 lines of code. We'll then explore the key ideas behind modern agents, including tool calling, conversation history, and stopping conditions.I'll also explain what frameworks actually do and which problems they're designed to solve. You'll leave with a clear mental model of how AI agents work and the confidence to choose the right approach for your own projects.Table of contents:- AI agents are simpler than you think: an 80-line implementation- What do we actually send to the LLM?- How does the LLM know what to do next?- How does tool calling work?- Conversation history- Stopping conditions- Where frameworks really help: retries, fallbacks, security, and conversation management
2026-12-04T14:05:00.000Z
QnA with Sylwia Laskowska
2026-12-04T14:15:00.000Z
Break
2026-12-04T14:45:00.000Z
"I'm AFK for a Bit": Letting an AI Agent Run Wild on WebGPU Kernels
Nico Martin
Browser-based AI inference is stuck between two bad options: follow a standard and get portability at the cost of speed, or hand-tune your own kernels and burn weeks of deep GPU expertise per model. For Transformers.js, we tried something that probably shouldn't have worked as well as it did: handing that hand-tuning work to an AI coding agent, with way less supervision than seemed responsible. It found multiple-x speedups across LLMs, audio transcription and text-embedding models running in the browser, on hardware we already had.This talk is a case study, not a pitch. I'll walk through the loop that turned autonomous kernel optimization from chaotic into trustworthy, the one instruction that changed the agent's behavior more than any amount of prompt engineering, and the counterintuitive lessons from real experiments, including why our biggest wins did not come from clever algorithms and why you should never let your agent gaslight you into thinking it's done.
2026-12-04T15:05:00.000Z
QnA with Nico Martin
2026-12-04T15:25:00.000Z
Building Next.js for Agent Success
Aurora Scharff
As coding agents write more of our software, token efficiency becomes part of developer experience. The framework influences the time and effort agents spend, how well they can verify their work, and the performance and user experience of the applications they build.This talk shares how we’re using evals on the Next.js team to measure and improve agent success. We’ll look at what we’re learning, how framework features and automated workflows support that work, and what that means for developers building with agents.
2026-12-04T15:45:00.000Z
QnA with Aurora Scharff
2026-12-04T15:55:00.000Z
When Your Coding Agent Does Something You Didn't Ask For
Natalie Pistunovich
We all write code with AI tools now, and those tools are basically agents with real access to our machines. This year gave us a good look at what happens when that goes sideways. The case this talk makes is that these problems aren't new or mysterious. They're the same kinds of security bugs we've dealt with for years, just wearing an agent costume: something untrusted comes in, and something with real permissions goes out.
2026-12-04T16:15:00.000Z
QnA with Natalie Pistunovich
2026-12-04T16:25:00.000Z
Determinism over Prompts: When the Agent Ships and Nobody Reviews
Daniel Sogl
Ten files changed, pull request open, four minutes of work. The agent ships – but nobody reads what's being produced anymore. What happens to the domain logic when code stops being the artifact humans use to verify it? And why do teams get slower even as they produce code faster?As a Microsoft MVP for Developer Tools, Daniel helps teams build agent-driven workflows – and shows the patterns where they consistently break down: architectures that erode under the flood of files, untested legacy code, requirements that end up in the prompt instead of in acceptance criteria.
2026-12-04T16:45:00.000Z
QnA with Daniel Sogl
2026-12-04T16:55:00.000Z
Claude Code Isn’t Going to Replace Engineers (Yet)
Olena Kutsenko
AI will not replace data engineers tomorrow. But it is already changing how we work — including, occasionally, helping us do stupid things with more confidence.Used badly, AI will make us weaker engineers. We outsource judgment, trust the output too quickly, miss the details, and slowly lose the habit of critical thinking. Used well, it can make us sharper.
2026-12-04T17:15:00.000Z
QnA with Olena Kutsenko
2026-12-04T17:25:00.000Z
Red Teaming AI Performance Ideas: What Survived Measurement
Yomi Eluwande
We used AI agents to speed up the hand-tuned flamegraph renderer in our continuous profiling product. Across 43 agent passes, we got 66 proposed optimizations. Most were wrong, too small, or failed once measured. The one that shipped took normal renders from about 21ms to 6ms, and inverted renders from about 44ms to 8ms in production A/B tests.This talk is about using agents for React performance work without trusting their first answer.
2026-12-04T17:45:00.000Z
QnA with Yomi Eluwande
Discussion rooms
2026-12-04T09:30:00.000Z
The Future of the Developer: Craft and Competence in the Age of AI
Julia Kordick
2026-12-04T11:15:00.000Z
Skills, MCPs, Subagents, Hooks… Is Your Setup Overengineered?
Hamid Shoja,
Kristiyan Velkov,
Natalie Pistunovich,
Guilherme Dalla Rosa,
Georgios Diamantopoulos,
Julia Kordick,
Alina Astapovich
2026-12-04T14:45:00.000Z
The Token Bill Is Here: Is AI Coding Actually Cheaper and Faster?
Filip Hric,
Kristiyan Velkov,
Yomi Eluwande,
Sylwia Laskowska
Times below are shown in your local browsers time zone.
2026-12-07T15:00:00.000Z
2026-12-07T16:00:00.000Z
2026-12-07T17:00:00.000Z
2026-12-07T18:00:00.000Z
2026-12-07T19:00:00.000Z
Agentic Engineering Track
2026-12-07T15:00:00.000Z
Opening
2026-12-07T15:15:00.000Z
The Orchestra Plays Itself. Who Runs the Loop? Lessons from Two Spec Implementations.
Vladimir Novick
Last time at AI Coding Summit London I gave you From Prompting to Orchestrating — the argument that coding with fleets of agents is a systems problem, and the spec (grounded in dozens of research papers from the major labs) that names the fix. Then I went and built that spec. Twice. Once as an autonomous daemon that runs the whole loop for you, once as a plugin that lives inside your own coding session.
2026-12-07T15:35:00.000Z
Architecting for Agents: Your Codebase Design Matters More Than Your Prompts
Waldemar Neto
2026-12-07T15:55:00.000Z
How Memory Works, from the Human Brain to AI Agents
Alina Astapovich
AI agent memory might sound complicated until you realize there's already a perfect example of it, and it's a human brain.That's the whole idea behind this talk - agent memory becomes easy to understand the moment you compare it to your own. We'll take the different types and techniques of AI agent memory and match each one to the part of the brain it mirrors, so instead of learning abstract concepts, we'll just recognize how our own mind already works. Then we'll see how it works in a real agentic system we built in production, with these techniques in action: how it decides what to remember, how it recalls the right thing at the right moment, and how it forgets the rest.
2026-12-07T16:15:00.000Z
Before You Pick an Agent Orchestrator: What I Learned Wiring a Self-Driving SDLC
Yedidya Schwartz
2026-12-07T16:35:00.000Z
Stop Copy-Pasting Your AI Agent Config
Dante De Ruwe
Every new project starts with copy-pasting agent instructions, skills, hooks and custom agents from the last one. Improvements have to be propagated everywhere, and within months you have a dozen repos running subtly different versions of the same setup.I fixed this for our team by building a shared Git repo of composable agent packages, managed by APM (Agent Package Manager) and installed in one command. In this lightning talk, I'll walk through how I structured the repo, how each project declares only the packages it needs, how you can mix in community-built skills alongside your own, and how APM deploys the right config to the right tool. You'll leave with a concrete setup you can bring to your own team that same week.
2026-12-07T16:55:00.000Z
Break
2026-12-07T17:05:00.000Z
Your Agent Docs Are Lying: Structuring and Testing Instruction Files for Coding Agents
Hamid Shoja
When we audited our AI coding-agent instructions (CLAUDE.md files, skills, agent definitions) against our actual monorepo, we found docs that were confidently wrong: styling guides producing CSS that never matched the build, test templates that crashed on render, "best practices" used by 1 of 50 real files. Every wrong doc cost a multi-thousand-token debug loop each time an agent followed it. This talk is the playbook that came out of fixing it: how to distribute knowledge across instruction surfaces based on their loading semantics, and how to test docs the way you test code.
2026-12-07T17:25:00.000Z
Delete Your Subagents. Keep Your Delegation.
Tushar Amrit
Nora is the agent harness that runs my company of 1500+ employees and thousands of agents. Everyday Nora handles about 2k+ Slack requests and 300+ pull requests generation across 300+ team-specific personas. We built it the way most teams build agents today, with a central router delegating to specialist subagents for Jira, Slack, Salesforce, and a half-dozen other domains. Each one carried its own prompt, tools, and LLM call.Over the past year we deleted almost all of them.The pattern was the right call for the models we had in 2024, when breadth made them hallucinate tool calls and loop.
2026-12-07T17:45:00.000Z
Why a Design System Wasn’t Enough for AI-Generated UI
Szymon Chmal
The team already had a design system, but it covered only part of the ecosystem. Web and mobile interfaces were still built separately, patterns drifted between products, and feedback arrived late. AI could speed up code generation, but without shared context and enforceable rules, it could reproduce the same inconsistencies faster.In this talk, we’ll show how we rebuilt that workflow around shared React and React Native components, agent-accessible design context through MCP, Figma Code Connect, pre-write guardrails, and automated visual checks. We’ll also explain how moving working prototypes ahead of final design sign-off brought stakeholder feedback into the process earlier.The result: more than 60 mapped components, a visual-diff threshold below 2%, and prototype time cut from about an hour to ten minutes.
2026-12-07T18:05:00.000Z
Vibes Don't Scale
Georgios Diamantopoulos
A founder spent six weeks with AI tools and shipped 300,000 lines: a WhatsApp clone with real users and a polished UI. Underneath, security holes, queries that pull an entire table to count its rows, and a codebase three senior engineers couldn't untangle. With low-code the limit was visible: the blocks ran out and you called an engineer. Vibe coding has no visible wall.
2026-12-07T18:25:00.000Z
The Critical Engineer: Collaboration When AI Makes Code Cheap
Dries Samyn
The SDLC has barely changed since software engineering began: a linear, largely single-threaded process, optimised for a world where writing code was the expensive part. AI has made expression cheap, and the whole coordination layer is now built for a scarcity that no longer exists. I argue the unit of coordination should move from the ticket to the plan, the reasoning behind the work, as a shared, continuously changing artefact rather than something local to one engineer.
2026-12-07T18:45:00.000Z
From Copilot to the Dark Factory
Pini Reznik
AI coding tools make developers faster, but they do not automatically make organisations ship faster. PR volume rises, review queues grow, tests weaken, and context, security, and platform bottlenecks become visible. AI does not remove the constraint; it moves it.This talk combines the AI Adoption Ladder with the emerging architecture of software factories. It shows how teams progress from first licences to agentic delivery, and the six systems required to scale safely: orchestration, sandboxes, context, validation, governance, and learning loops.Attendees will learn how to identify their next bottleneck and build beyond “everyone gets Copilot.”Licences create activity.
2026-12-07T19:05:00.000Z
AI Ruined Engineering Interviews. Now What?
Dennis Nerush
AI has completely changed how software engineers work. But interview processes haven't caught up.Coding assistants solve LeetCode problems in seconds. AI can generate polished system design answers. Almost every candidate walks into an interview with powerful AI tools, yet many companies are still trying to evaluate engineers as if none of this exists.So what actually separates exceptional engineers from everyone else?After interviewing hundreds of engineers at Elementor, I realized we had to stop testing who could write code without AI and start testing who could build, reason, and make decisions with it.In this talk, I'll pull back the curtain on what modern engineering interviews actually measure.
2026-12-07T19:25:00.000Z
Closing
Developer & Workflow Track
2026-12-07T15:00:00.000Z
Opening
2026-12-07T15:15:00.000Z
Teaching AI to Build Software My Way
Gil Zilberfeld
I've been doing TDD and clean architecture for years. When I started using Claude Code to build a real application, I wanted to create it the right way from day one - test-first, walking skeleton, steps sized for review.And it worked. Partially. The agent could explain TDD better than most developers, but then skipped the red phase in the same session.
2026-12-07T15:35:00.000Z
Define Done Before the Agent Starts: Turning Product Scenarios into Executable Acceptance Tests
Innokenty Bodrov
The core idea: coding agents have made implementation fast and inexpensive, but acceptance remains a human bottleneck. Before any code is generated, user scenarios should therefore be translated into executable end-to-end acceptance tests.The workflow:Context → Problem → Specification → User Scenarios → End-to-End Tests → Agent Implementation → Human UATThere are two points where human judgment is essential:At the beginning: deciding what to build and why, defining the scope, and making architectural decisions.At the end: accepting or rejecting the result. A green test suite indicates engineering readiness, but it does not prove that the product delivers value.
2026-12-07T15:55:00.000Z
The PR Is the Eval
Jack Fitzsimons
Most coding agents are evaluated at the moment they answer. Software teams discover whether an answer was useful much later: a test fails, a reviewer requests changes, the pull request stalls, or the code ships. This talk shows how to turn those delayed signals into a continuous evaluation system. We instrument AI conversations, tool calls, diffs, commits, CI runs, review comments, and merge outcomes, then join them into one trace from prompt to production.Using a working implementation, I’ll walk through the event model, correlation logic, and queries that separate accepted work from rework and repeated failure.
2026-12-07T16:15:00.000Z
Static Enforcement for Agentic Code
Jakob Heuser
AI agents now write more code than any team can review diff by diff. This talk is a simple way to split the rules your code must never break: static rules you can check without running userland code, and runtime rules that need real execution to verify. You'll leave knowing what to enforce statically, what needs a runtime check, and how to generate both from your own codebase so your standards hold as agents outrun your reviewers.
2026-12-07T16:35:00.000Z
(MCP Security) - How Your Friendly MCP Tool Might Betray You
Daniel Ostrovsky
We all love the convenience and power of AI-enhanced tools using MCP. But what if these handy servers had a hidden dark side? Let's dive into real-world examples of how MCP servers can silently leak your data, execute malicious commands, or even grant attackers access to your systems.You’ll learn about sleeper attacks, tool poisoning, shadowing, and remote code execution—complete with chilling real-life cases and practical advice on defending yourself.This is an eye-opening session that exposes why blind trust in MCP is a dangerous game.
2026-12-07T16:55:00.000Z
Break
2026-12-07T17:05:00.000Z
When Software Stops Being Deterministic: Rethinking Engineering Practices for AI-Native Systems
Susanna
For decades, we've built software around a simple assumption: the same input produces the same output. If behavior changes, we can usually trace it back to a code change. We write tests, review diffs, deploy to staging, and rely on CI because software is fundamentally deterministic.LLM systems break that assumption.As you build with language models, behavior increasingly emerges from the interaction between prompts, retrieval, context, model choice, and evaluation—not just the application code itself. Features can regress without a single line of business logic changing.
2026-12-07T17:25:00.000Z
Move Fast(ER), Stay Compliant
Florian Margaine
AI-assisted coding is transforming how we build software - from copilots to autonomous agents, developers ship faster than ever. But in enterprise environments governed by ISO 27001, SOC 2, and strict SDLC requirements, speed doesn't exempt you from compliance. If you didn't write the code, where do you safely run it?This talk explores sandboxing strategies for AI-generated code: isolated environments that sit between your laptop and production, providing network isolation, ephemeral reproducibility, and audit trails. We'll also tackle the data problem - why empty sandboxes aren't enough, and how AI-generated mock data and copy-on-write production snapshots each solve different challenges.Through real-world stories, we'll see why the "legacy user" can't be mocked, and what a proper AI-assisted development workflow looks like in a compliance-driven organization.
2026-12-07T17:45:00.000Z
Turn Agent Incidents Into Regression Tests That Actually Hold
Tisha Chawla,
Susheem Koul
"How do you write a regression test for a bug that refuses to reproduce? A production bug you cannot reproduce is a bug you cannot prove you fixed. If you have ever patched an agent, rerun it, watched the failure vanish, and still had no idea whether you fixed it, you know the problem. Rerunning a nondeterministic system changes the very thing you are trying to measure, while replay holds it fixed.But what if you could replay the incident exactly as it happened and change only the one boundary you fixed?
2026-12-07T18:05:00.000Z
The Reliability Harness for AI Agents on AWS
Guilherme Dalla Rosa
Demo agents break in production: loops, wrong tools, leaked context, silent regressions. Not a model problem. This session builds the reliability harness, a deterministic layer that observes, constrains, bounds, and evaluates the model with AWS building blocks. Numbers are real traces or evals.
2026-12-07T18:25:00.000Z
Your AI Wrote It. Can You Debug It at 2 AM?
Maish Saidel-Keesing
It is 2 AM. Production is down, and the code that broke was written by an agent nobody on your team fully understands. This is the real cost of AI coding: you shipped fast, then traded away the one thing an incident demands, the ability to reason about your own system. Green tests hid it.
2026-12-07T18:45:00.000Z
Our Software Factory Ships Through MCP: Slack In, PRs Out, CI Decides
Kaan Karakas
How we wired production MCP servers into a company operating loop where Slack feedback becomes Linear work and real PRs, while CI stays the merge gate.
2026-12-07T19:05:00.000Z
Closing
Discussion rooms
2026-12-07T15:30:00.000Z
Spec-Driven Development: Did We Just Reinvent Waterfall?
Innokenty Bodrov,
Georgios Diamantopoulos
2026-12-07T16:30:00.000Z
Deterministic Workflows vs. Autonomous Agents: How Much Autonomy Is Too Much?
Guilherme Dalla Rosa,
Georgios Diamantopoulos