Name: AI Coding Summit London
Start: 2026-07-06T11:00:00.000Z
End: 2026-07-07T17:00:00.000Z

Lera

Kseniia Korostelova

David Pugh

Nihan Bircan

Azadeh Farshidi

Karyna Bunta

Alex Hayton

Myron Davis

Josh Riesenbach

Sanketh Kumar

Filip Verswijver

Pratik Ghosalkar

Rishi Narang

Arash Sarfehjou

Vitor Barbosa

Basseydou OUATTARA

Julián Parrilla Calvo

Fathima Fasna

Antwan Sherif

Srikanth Doddi

Jacquelyn

Denys Kniaziev

Dennys Antunish

Sudhakar Kirubakaran

Varun

Michael Chiche

Mort Hafez

Ivan Almasi

Julia Dorali Garcia

Sergei Svekolnikov

Steven Thomas

Sauparna Sarkar

Iandra Bedin

Keertivaas S

I'm not here to tell you software engineering is ending soon. Nobody can put a reliable date on that, and pretending otherwise is a distraction. But we also have to admit something humbling: a year ago, most of us would not have predicted coding agents would be this good. That should make us less confident about predicting what they'll be able to do one year, or five years, from now. So let's use "The Last Software Engineer" as a thought exercise. If AI keeps taking over more of the implementation work, what remains most human and valuable for us to do? In this talk, we'll take one step back from the hypothetical end and focus on the durable skill that has always separated great engineers from merely productive ones: judgment. The future belongs not to people who only know how to build, but to people who know what should be built. We'll talk about product engineering, accountability, trade-offs, constraints, evaluation, and how to keep making software worth having in an AI era.

The Last Software Engineer

Kent C. Dodds

On my YouTube channel AI Coding Daily, I've published 100+ videos comparing different models for coding: Opus vs GPT, Kimi vs GLM, New vs Older versions, Effort Medium vs High, etc. Now I see clear patterns for evaluating models and deciding which one to choose for specific tasks and projects.

Learnings From 100+ Experiments Comparing LLMs for AI Coding

Povilas Korop

What makes an agent skill reliable, performant, and maintainable? We will explore a robust approach to skill design, starting with foundational best practices, moving into automated skill generation, and validation. The second half of the talk focuses on the critical role of evaluation, demonstrating how tools like SkillGrade and benchmarks like SkillBench allow developers to catch regressions and ensure their agents behave predictably in complex environments.

Skill Design for LLM Agents

Minko Gechev

This talk dives into how developers can build structured, repeatable coding workflows using Claude Code's ecosystem: Skills, Subagents, settings, Hooks, and MCP servers. I'll walk through the architecture behind Claude Code Templates, an open-source project with 120K+ npm downloads and 23K+ GitHub stars, showing how these components work together to create composable, reusable patterns within real software development projects. From automating code reviews to orchestrating multi-agent tasks, we'll cover practical setups that teams can adopt immediately.

Skills, Templates and Components for Claude Code and AI Coding Workflows

Daniel Ávila

Developer tools are no longer built only for humans at a terminal. They are also used, tested, broken, and improved by AI agents. In this session, I will share how to create tools where you can have agent-reported issues, automated reviews, refactors, and release workflows to the point that such tools start to maintain themselves, and help one maintainer operate closer to a small team.

For Agents, By Agents: Building AI Tools That Maintain Themselves

Rudrank Riyam

This talk shows how to design and operate QA agents that run against real iOS and Android devices hosted remotely. We’ll cover the architecture of a reliable agent, connecting Linux-based infrastructure to mobile devices running on macOS, and integrating outputs like screenshots, recordings, and logs directly into pull requests.

Automating Mobile QA with Cloud Agents

Michał Pierzchała

Coding agents are quickly becoming part of day-to-day engineering work, but most people still lack visibility into what these agents are actually doing. Marius will share findings from Apollo’s research into tens of thousands of real-world coding agent traces: from direct security risks like dangerous commands, data exfiltration, and insecure code changes, to quieter failures like instruction drift, scope creep, and overclaiming. He’ll explain why coding agents should be treated as untrusted infrastructure actors, not just productivity tools. The talk will also show how Apollo is addressing these risks with Watcher, a real-time oversight and control layer for coding agents.

Real-Time Observability and Control for Coding Agents

Marius Hobbhahn

We thought AI would help us write code faster. Instead, it's changing what coding actually is. We started with prompts, then copilots, then agents. Each step felt like a leap forward — until you try to build something real at scale.Because prompts don’t remember. Agents don’t coordinate. And models still hallucinate and miss context. What’s emerging instead is a different approach: not writing code line by line, but designing systems that produce, validate, and evolve code. Instead of a single assistant, we orchestrate multi-agent workflows — planning, implementing, reviewing, and testing — with shared context and feedback loops.In this talk, we’ll cover: - why prompt-based and single-agent approaches break down - how multi-agent systems reshape development workflows - practical patterns for planning, execution, validation, and control loops - where things fail — and how to make systems reliable We’ll show how structured orchestration makes agent-based systems actually work in practice — especially when moving beyond isolated, task-level automation. The shift isn’t from coding to prompting — it’s from coding to designing systems that write code.

From Prompting to Orchestrating: Coding Is Now a System

Vladimir Novick

Modern AI systems don’t just rely on static datasets—they depend on continuous streams of real-time data to train, update, and make decisions. But what happens when that data can’t be trusted? In this talk, we explore how streaming data pipelines—often built on systems like Apache Kafka—are becoming a critical and undersecured attack vector for AI-driven applications. Rather than targeting models directly, attackers can manipulate the data flowing into them. By injecting, modifying, or replaying events in real-time streams, adversaries can: - Poison training data and degrade model accuracy over time - Manipulate real-time features used in fraud detection or recommendation systems - Trigger unintended behaviors in downstream AI systems - Quietly influence decisions without ever touching the model itself We’ll examine how these attacks work in practice, from subtle data drift manipulation to targeted event injection, and why they are difficult to detect using traditional security tools. The talk will break down the weak points in modern data pipelines: - Lack of validation and trust boundaries in event streams - Over-reliance on infrastructure-level security (encryption, ACLs) - Blind spots in monitoring data integrity and semantic correctness We’ll also explore how these risks evolve in systems that continuously retrain or adapt, where corrupted data doesn’t just affect a single decision—but becomes embedded in the model itself. Finally, we’ll discuss defensive strategies that go beyond securing infrastructure: treating data as an attack surface, implementing validation and anomaly detection at the data level, and designing pipelines that can detect and recover from adversarial inputs. This talk offers a new perspective on AI security - not by focusing on models, but on the data pipelines that feed them, where some of the most impactful and least visible attacks can occur.

Streaming Systems, Hidden Risks, And AI-driven Consequences

Olena Kutsenko

When you need to apply the same change across hundreds of repositories, manual PRs don't scale and traditional codemods can't handle the unexpected. In this talk, I'll walk through the engineering journey from building a single-repo migration skill to deploying a fleet of parallel AI agents that autonomously process repositories, fix breaking changes, and report progress — all without human intervention. You'll learn the architecture behind cost-aware model routing, baseline comparison to avoid false positives, race-condition-free parallel execution, and risk-ordered rollout. I'll share what worked, what broke, and why a percentage of repos still needed a human. This isn't a demo of AI writing code. It's a production playbook for running AI agents as automation at scale, applicable to any fleet-wide change that you can take back and adapt to your own fleet-wide change programmes the week after this talk.

From One Repo to Hundreds: Building an AI Agent Fleet for Large-Scale Code Migrations

Konstantinos Leimonis

The workshop focuses on theory and practice building production-ready AI agents with Node.js and modern Agent SDKs. We will use a real codebase as an execution environment to explain the core concepts behind agents: the agent loop, tool calling, structured outputs, context management, guardrails, tools, and human approval. We will build a Node.js SDK-based engineering agent that receives a development task, inspects a repository, proposes and applies safe code changes, runs validation checks, and exports execution artifacts to a messenger/storage. We will also cover how this agent fits into a broader production architecture: where MCP, orchestration, multi-agent patterns, CI/CD, security boundaries, observability, and workflow tools such as n8n may be useful. By the end of the workshop, participants will understand not only how to use an Agent SDK, but also what remains their responsibility when designing safe and maintainable agent runtimes.

The Agent Runtime Workshop: Node.js, Tools, CI/CD, and Guardrails

Alex Korzhikov

AI-generated code is becoming the norm, but who reviews the reviewer? In this session, we explore how to close the feedback loop by letting AI agents review AI-written code. We'll look at local agent setups as well as cloud-based services like GitHub Copilot code review or Greptile, and discuss when each approach makes sense. Walk away with a practical mental model for building a self-correcting AI development workflow, without losing control over your codebase.

AI Reviews AI – Closing the Loop in Agentic Development

Daniel Sogl

AI coding tools are good at writing local diffs, but they still miss repo-wide truth. In large TypeScript and JavaScript codebases, that means dead exports, duplicated logic, accidental boundary violations, and complexity creep after every “small” AI refactor. In this talk, I’ll show a practical workflow for working with large codebases using AI: let the agent generate, run deterministic codebase analysis, feed the findings back via CLI/MCP, and gate drift in CI before it lands. Fallow is the case study, but the workflow applies beyond one tool.

Fast Code Generation Is Easy. Safe System-level Change Is Not.

Bart Waardenburg

There is no single correct way to assemble a software factory. Labs want us to trust agents more than we should. Tech influencers gloss over important, practical details. This workshop introduces several composable patterns for making a codebase more factory-like: to improve the throughput, quality, and verifiability of autonomous agent work in your project.We will cover: - Planning the work that gets handed over to a software factory- Converting plans and specifications to durable internal docs (and rules) that don’t go stale- Task decomposition for coding agents, and the tools that help with it- Review strategies and tools that can manage massive PRs - Agent-friendly QA setups that allow coding assistants to verify their work and fix bugs before human review- When you can safely skip human review entirely- The role of sandboxes (local and remote) for scaling and handling agent work on your codebase

Assembling Your Software Factory

Brett Beutell

Hard crashes are easy: the agent throws an error, you fix it, and you move on. The harder problem is drift, when the agent technically succeeds but slowly stops doing what you meant. Outputs become vaguer, tool choices grow stranger, and costs start to creep up.In this talk, the speaker examines how to detect behavioral drift before users notice, borrowing from process control theory and anomaly detection in industrial systems. The session explores what the benchmark of “normal” actually means, and how to build the feedback loops needed to catch drift early.

 AI Agents Drift: Identifying and Correcting Subtle Failures

Sam Komesarook

What can more than 20M public GitHub commits tell us about Claude Code's reach? In this talk, we move beyond vendor narratives to look at the real data: which developers are using Claude Code, what they're building, and crucially, what kinds of problems it's being applied to at the serious end of the stack.

What Claude Stats Tell Us About AI Coding Tools

Jodan Alberts

Most developers using AI coding tools hit the same wall on real projects: the demos look magical, but production work falls apart. This workshop shows why — and what to do about it.The core lesson: execution is fast and cheap only when preparation is deep.What we'll build, liveFrom an empty directory to a deployed production app — a mobile-first Conference Companion App with the event schedule, speaker profiles, search, and favourites. Attendees will open it on their phones before the session ends. The four stages of shipping with AIYou'll see a complete production workflow, deliberately weighted toward the work that actually determines quality:- Research — Gathering everything the AI will need upfront: official docs, code patterns, real data. By execution time, nothing has to be searched for. This is where quality comes from.- Planning — Breaking the app into clear tasks with acceptance criteria, written live. Skipping this is why most AI builds fail.- Execution — Ten tasks running in parallel via git worktrees, orchestrated by Navigator (a Claude Code plugin) on a React/Next.js stack. Code and docs written together.- Review &amp; Ship — Quality gates (tests, lint, types, build), clean commits, merge, deploy to Vercel. Live URL shared with the room. Bonus: Human + Claude Code vs. fully autonomous agentWhile the live build runs, Pilot — our autonomous coding agent — builds the same app from the same spec, on its own, in a separate repository. At the end, we open both side by side: two working apps, two pull request histories, two live URLs. One human-driven, one fully autonomous. You'll leave withA repeatable workflow for shipping real software with Claude Code, plus concrete techniques you can apply to your own projects on Monday morning.

Advanced Claude Code — Production Workflows, Subagents, and Autonomous Execution

Aleksei Petrov

AI coding assistants are evolving from simple autocomplete to autonomous agents that can interact with external systems. But how do you teach an agent to follow your workflows and use the right tools at the right time?In this hands-on workshop, you'll discover:<ul><li>What MCP (Model Context Protocol) is and how it standardizes tool integration for LLMs</li><li>How Agent Skills package domain-specific knowledge and workflows for AI agents</li><li>The key differences between MCP servers and Skills, and when to use each</li><li>How to create a custom Skill that orchestrates multiple MCP tools into a cohesive workflow</li></ul>By the end of this session, you'll build your own AI Skill that uses MCP tools — a Matrix-themed Neo fighting skill.Who should attend: This workshop is ideal for software developers who use AI coding assistants (Claude Code, Cursor, or similar) and want to extend their capabilities with custom integrations and workflows. No prior MCP or Skills experience required — just bring your curiosity and a laptop.

Building an Agentic Skill with MCP Tools

Misha Kazakov

Profiling JavaScript is mostly easy. However, how do you profile gnarly performance issues? In this talk, you’ll learn a practical AI-assisted workflow for finding rendering bottlenecks fast. Using a real-world CSS performance bug, we’ll cover techniques like commit bisection, standalone reproductions, synthetic stress tests, and auto-generated lint rules to prevent regressions. We choose CSS because it is famously difficult to profile -- there are no stack traces, obvious breakpoints, or clear debugging workflows, which is why many rendering bugs go unfixed until users complain that the page feels slow. However, the same methodology can be used in dealing with other performance issues. You’ll also see how to use the Chrome DevTools MCP to give Claude direct access to a live browser session and accelerate investigation without replacing engineering judgment. The result is a repeatable process for going from “the page feels slow” to a pinpointed line of CSS in under an hour.

Debugging Performance With AI

Bernie Sumption

Don’t get left behind—discover how AI is revolutionizing software engineering at the AI Coding Summit. Dive into cutting-edge talks and hands-on workshops on AI-powered software development. Network with industry leaders, explore game-changing tools, and stay ahead in the fast-evolving world of AI-driven development. Do not miss the biggest shift in software engineering.

AI Coding Summit

I'm attending AI Coding Summit with 5k other participants to learn how AI transforms software development and stay up to date with the latest AI tools - get your free remote ticket and join me there!

The first hybrid AI Coding Summit lands in London and stays online. A two-day hybrid conference featuring advanced talks and hands-on workshops on AI-powered software development, agentic coding patterns, orchestration, AI-assisted testing, CI/CD for agentic workflows, and building AI-native products. 20+ sessions, 200+ attendees in-person, and 5,000+ online. Learn repeatable playbooks from practitioners, not hype. Network with engineers and founders building the AI-native stack.

AI Coding Summit London

FocusReactive

Hygraph

Auth0 by Okta

<a href="https://focusreactive.com/" target="_blank" rel="noopener noreferrer">FocusReactive</a> is a specialist agency in AI-powered web platforms. As partners of Vercel, Shopify, Payload CMS and Sanity, we deliver production-grade AI integrations - from semantic search to open-source LLM toolkits for headless CMS and eCommerce.

FocusReactive is an&nbsp;<meta charset="utf-8" id="isPasted">engineering-led <a href="https://focusreactive.com/services/headless-cms-expert-agency/">Headless CMS Agency</a>&nbsp;and&nbsp;<a href="https://focusreactive.com/next-js-expert-agency/">NextJS&nbsp;development experts</a>. Independent partners of Payload CMS, Sanity, Storyblok, Vercel and Shopify. Delivering&nbsp;<meta charset="utf-8" id="isPasted">Composable content platforms built for AI SEO, growing teams, and marketing velocity.