AI Coding Summit London

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.

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.

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.

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.

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.

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.

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. 

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.

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.

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.

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.