KeynotesAIware 2025

Spec Kit is an open-source toolkit for Spec-Driven Development that treats the spec as the executable center of gravity—driving planning, tasking, and implementation across today’s AI dev tools. I’ll demo the Specify CLI to go from intent to working code, show how plan-and-task breakdowns keep outcomes on-spec, and discuss what reliably works (and where it doesn’t) when shipping real features with AI in the loop. We’ll also touch on current agent integrations (e.g., GitHub Copilot, Cursor, Claude Code, Gemini CLI) and the concrete developer workflows teams are adopting. GitHub I’ll preview two near-term enhancements we’re building to tighten reliability. First, checklists as first-class constraints: today they live inside spec templates; we’re lifting them out so teams can invoke reusable acceptance criteria on demand—gating generation, execution, and sign-off across runs. Second, a Polya-style loop—understand → plan → execute → review—operationalized end-to-end so humans and agents share one problem-solving rhythm. Together these changes aim to reduce rework, make “what good looks like” explicit and verifiable, and keep fast paths fast without sacrificing correctness.

Large Language Model (LLM)-based agent systems are emerging as a new software paradigm and have been widely adopted across diverse domains. As agent systems are inevitably prone to bugs and continually evolve to meet changing external requirements, maintaining them is therefore critical yet requires substantial effort. In this talk, we will present our recent work on maintaining and optimizing agent systems. We will discuss common quality issues that arise during agent maintenance and explore how existing software maintenance techniques perform when applied to agent systems. We will further address the cost challenges of multi-agent systems and introduce our recent budget-aware optimization technique for multi-agent systems.

Large language models have shown remarkable ability in code generation and comprehension, yet they still struggle to reason systematically or operate effectively within real development environments. In this talk, I will share our recent efforts to move beyond static prompting toward training LLMs that can think, act, and verify like developers. We begin by exploring how complex software issues can be decomposed into structured subtasks—planning, searching, and verifying—to teach models to perform hierarchical reasoning and adaptive decision-making. Building on this foundation, we extend the learning process to environments where models interact with external tools such as test runners, linters, and code search systems. Through this integration, models not only generate code but also validate and refine their own outputs through iterative feedback. Together, these developments point toward a new generation of agentic LLMs—models that bridge reasoning and execution, capable of autonomously debugging, verifying, and evolving software.

Large Language Models (LLMs) applications rapidly evolved from code completion tools (e.g., GitHub Copilot, 2021) to autonomous code agents capable of complex reasoning and workflow execution. In this talk, we examine the technical advancements and remaining challenges in using LLMs for code generation, drawing on recent work from Mistral’s code generation team. We’ll discuss key improvements in model architectures, training strategies, and evaluation frameworks, as well as open questions in the field.

Claude Code, Anthropic's flagship terminal-based coding agent, started as an interactive tool for writing software. But as we iterated on it, we discovered something more fundamental: an extensible infrastructure for building multi-agent applications with ease. Teams at Anthropic are already leveraging Claude Code to build code review systems, issue triaging pipelines, and more -- with greater intellectual depth than ever before. The key to building effective multi-agent systems is understanding the agent loop underpinning both the terminal UI and the SDK. We'll build intuition for this foundational concept, then explore Claude Code's various primitives that extend the loop: custom agents for delegation, skills for providing knowledge for Claude to look up, and hooks for injecting logic at decision points. We'll examine how these primitives enable the real systems mentioned above, and how Claude Code's evolution into the Claude Agent SDK enables attendees to build their own multi-agent development workflows.

Software collaboration platforms like GitHub provide perfect opportunities for agentic automation. At GitHub Next we have developed GitHub Agentic Workflows, a framework for exploring practical, safe semi-automated software automation for repo-centric behaviours, focusing on "Continuous AI" scenarios that parallel CI/CD DevOps - Continuous Documentation, Test Improvement, Perf Improvement, Accessibility Improvement and much more. By safely bringing agentic behaviours directly into the GitHub information space on GitHub Actions, we allow developers and enterprise agentic architects exceptional creativity in exploring how automated coding agents can boost team productivity aligned with team goals, opening the doors to a new era of semi-automated software engineering.

The command line is being reborn, transformed by the intersection of AI and developer workflows. In this talk, we'll walk through how Gemini CLI is reshaping developer productivity—from rapid prototyping and code generation to debugging, deployment, and automation. We'll explore how Gemini CLI wrote most of its own code and shifted from a single-command assistant to an extensible platform that elevates terminal-based development. We'll also cover the philosophy behind CLI-first AI tooling and the importance of UX in building the next generation of AI-native products.

“A hero can be anyone.” Bruce Wayne, The Dark Knight Rises (2012) Generative AI has transformed the way we develop systems at BT. Every developer has access to cutting edge coding assistants, the Batarang to their Batman if you will. But with the recent advancements in agentic frameworks making a utility belt of tools even easier to acquire, where should we next focus our attention? In this talk, I will take you through BT's journey with generative AI, starting with coding assistants, and finishing with what we believe to be the next step in the gen AI journey. I will introduce you to Alfred, the intelligence agent-turned butler ready to attend to your every need, whether it be drawing your architectural diagrams, or analysing them for quality and guardrail conformance. The journey will explore what is currently possible at the bleeding edge of AI supporting industrial software engineering, and we will use the opportunity to identify the next generation research challenges that once solved will allow everyone to be super heroes.

Large language models (LLMs) are rapidly transforming the practice of software engineering. Code correctness has been the primary focus for evaluating these models, but real-world software development requires much more. In this talk, I will discuss how we could move beyond correctness to address broader dimensions of LLM-generated code. I will use my recent work on efficiency, fairness, and diversity as examples, and discuss the challenges and opportunities that lie ahead in advancing LLMs for code.

In recent years, Large Language Models (LLMs) have shown impressive performance across a wide range of downstream applications, including software engineering. In this talk, we will discuss the history and recent trends of software engineering agents and present our work in this promising direction, covering both agent scaffold design (e.g., Agentless) and software-centric LLM post-training (e.g., SWE-RL and Code World Model).

Large language models (LLMs) have shown remarkable ability in generating texts across various domains, including code. However, there is a growing concern about hallucinations and whether LLMs can truly understand tasks and internal representations of code. In this talk, I will review LLMs’ abilities in code-related tasks through our lens of transferable knowledge. In particular, I will argue that although these models can perform well in benchmarks that involve restricted contexts and tasks, they in fact lack fundamental understanding of software beyond the contexts they have seen. I will also present our empirical findings and measurement that highlight the shortcomings of LLMs in tasks where context and prior knowledge are essential, along with our research agenda and direction to unlock their full potential in developer-facing tasks.