KeynotesAIware 2026

This talk traces how AI-driven software engineering—particularly bug finding—has evolved over two decades: from statistical machine learning and handcrafted features to today’s large language models and agentic pipelines. The central bottleneck has shifted—from features to data, and from implementation to validation and verification. Drawing on work spanning automated code generation, bug and vulnerability detection and repair, binary analysis, and robot task planning, this talk argues that the field is undergoing a broader transition from features to data and domain knowledge. Here, “code” is interpreted broadly: beyond source code to binaries, HTML and CSS, and LaTeX—and beyond functional correctness to maintenance and security. LLMs are powerful across all of these settings, yet they are not a silver bullet: they hallucinate fixes, overfit to test suites, and degrade on real-world tasks. The talk closes by examining what will likely define the decade ahead for software engineering research, including data generation, specification- and test-driven software development, rigorous benchmarks, and neurosymbolic AI.

AI is genuinely lowering the barriers to building software - but democratization is the surface effect. The deeper transformation is structural: AI shifts the primary bottleneck in software development from implementation to system design and reasoning. In agent-driven workflows, the constraint is no longer writing correct code across a large surface area. It is making good architectural decisions, managing system-level tradeoffs, and reasoning coherently across concerns - performance, modularity, data flow, hardware characteristics - that previously required deep specialization or large, coordinated teams. Individual developers and small groups can now operate fluidly across layers that were previously siloed not by technical necessity but by organizational scale. This shift raises fundamental questions for the software engineering research community. How do we evaluate design quality in systems that evolve continuously under agent-driven modification? What does meaningful modularity look like when the cost of cross-boundary reasoning approaches zero? How should practices like refactoring, testing, and performance validation be reconceived when the artifact being maintained is as much a set of agent instructions as a codebase? This talk draws on experience building AI-powered developer tools at AWS and working on AI acceleration across edge and cloud at Arm to ground these questions in observable shifts in how complex systems are actually being built today - and to argue that the SE community's next productive frontier is not productivity measurement, but the theory and practice of design in the age of capable agents.

In this talk, Pascal Kesseli explores how formal methods can enhance reasoning capabilities in modern AI systems, drawing on his research at the University of Oxford and his work at Meta GenAI and FAIR. He introduces an agentic inference-time reasoning engine, Logic.py, and shows how it supports structured decision-making in agents. He then turns to follow-on work that applies AlphaGo-style reinforcement learning training pipelines to improve reasoning behavior, and he closes by outlining how inference-time and training-time approaches are beginning to converge into a unified direction for building more capable, dependable agents.

The paradigm of Generative AI is rapidly evolving from passive assistants to autonomous entities. Moving beyond the chatbot and simple code-completion copilots, the next generation of AI agents functions as digital colleagues capable of end-to-end task execution. This talk explores how these agents leverage code not merely as an output, but as their fundamental reasoning engine and interface for interacting with the world. We will focus on the shift from manual prompting to high-level Steering, discussing how human intent can guide code-driven agents to autonomously navigate complex workflows, resolve software engineering challenges, and bridge the gap between abstract requirements and finished, functional results.

In this talk, I will introduce Spec-Driven Development (SDD) in the era of large foundation models and autonomous AI agents, arguing for re-centering the Software Development Life Cycle (SDLC) around specifications to improve alignment, reliability, and long-term maintainability. By placing structured, semi-formal specifications at the core of development, we can ensure higher fidelity between intent, implementation, and system behavior. I will use Kiro (https://kiro.dev/) as a concrete example to demonstrate how development begins with specifications that systematically guide code generation, validation, and evolution. We will explore how SDD supports both greenfield systems, by enforcing clarity and architectural rigor from inception, and brownfield systems, by extracting and leveraging specs from legacy codebases for feature development, bug fix, and modernization. I’ll discuss how coding agents grounded in specs can improve correctness, reduce hallucination, and enforce invariants, while also highlighting open challenges such as spec completeness, ambiguity, trust, and semantic alignment. Finally, we’ll discuss the need for offline benchmarks, high-quality {Code, Spec} datasets, and rigorous evaluation metrics, and conclude with a forward-looking perspective on how specifications may evolve into the primary artifact of software engineering, with code becoming a compiled byproduct of intent.

A coding agent's harness, the software that mediates the agent's interaction with the world, determines how much of a model's capability translates into delivered engineering work. As models have grown more capable, Claude Code's harness has evolved alongside them. This talk is a retrospective on Claude Code's public releases since the start of the year, detailing the design considerations behind each and the aggregate patterns they reveal. We frame each agent session as a trajectory: a search through the user's environment that accumulates knowledge and enacts changes within it. Through that lens, the year's launches sort into two moves: letting trajectories run further per unit of human attention (auto mode, routines, remote control, worktrees), and managing what each trajectory is conditioned on (memory, multi-agent code review). Meanwhile, increased model capability strengthens the trajectories themselves. We conclude by examining how to orient these trajectories toward desired outcomes. Once step-by-step correctness is no longer the constraint, the binding problems become reconciliation—merging many independently correct trajectories into one repository—and validation—making it cheap for humans to review and revise intent for agents that are competent but not clairvoyant. Both can be software engineering problems, and we offer them to this audience as open questions.