Schedule

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.

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.

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 reliableWe’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.

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.

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.

Anyone can spin up an AI agent in five lines. Would you give that agent a refund button? In this demo-driven talk I build a customer support bot with LangGraph, the framework behind agents at Klarna, Uber, and J.P. Morgan, to show why control matters in production.

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.

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.

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.

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.

The default way we've used coding agents is conversational: you ask, read the reply, ask again. Your attention is what keeps the whole process moving, and it's the sole bottleneck. That model is starting to break down at scale. What's emerging instead is a shift in where the engineering effort goes: away from crafting individual prompts, toward building a system that surfaces the work, dispatches it to agents, validates the output, tracks state, and picks (or invents) the next task on its own.

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.

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.

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 itselfWe’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 correctnessWe’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.

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.