Master-Course: Agentic Software Engineering (ASE) WS 2026/27
Course number and language
L.079.05705
The teaching language will be English. Questions in German will be permitted.
Public course material
Public course material is being made available on this page.
Registering and communicating
To attend the course, you have to register in the PAUL system as a participant.
To ask questions, please use the discussion forum in PANDA so that others can benefit from the answers as well.
If needed, we will also send updates through PANDA circulars.
Lecture Schedule
This schedule gives a rough indication of which topics will be covered when.
The following course schedules are non-binding and may change at any time and without prior announcement.
| Date | Lecture topic | Lecturer |
| 13.10. | Introduction and course outline | Bodden |
| 20.10. | Retrieval-Augmented Generation (RAG) | Soltaniani |
| 27.10. | Tool use and function calling: interfaces between agents and development tools | Bodden |
| 03.11. | Continuation of previous topic | Bodden |
| 10.11. | Knowledge and context engineering for SE tasks: providing repositories, issues, tests, and documentation as context | Bodden |
| 17.11. | Organization of long-term and short-term memory | Bodden |
| 24.11. | Economic perspective: productivity effects (empirical studies), cost, latency, and model economics in production agent deployment | Bodden |
| 01.12. | Abstract: AI coding agents are rapidly transforming software development, but generating code that looks correct is fundamentally different from engineering software that is reliable, maintainable, and secure. This talk explores the engineering principles behind modern coding agent harnesses, using Kiro as a practical example of how to move beyond simple prompt-driven code generation. We will examine Specification-Driven Development (SDD), where structured requirements, design documents, and implementation tasks provide agents with an explicit understanding of developer intent throughout the software development lifecycle. We will explore how agents can leverage developer tools such as Language Server Protocol (LSP) diagnostics, AST-based code navigation, and semantic refactoring to interact with codebases more precisely and reduce common programming errors. The talk will also cover automated testing, property-based testing, and specification-to-code validation as complementary techniques for checking whether generated implementations satisfy their intended behavior. Going a step further, we will discuss how formal methods and theorem provers such as Lean can help verify properties of the coding agent's own harness, rather than just the software it produces. Finally, we will discuss how security requirements can be incorporated directly into specifications to make security an integral part of the development process. Through practical examples and lessons from building Kiro, the talk will highlight how ideas from programming languages, software engineering, static analysis, and formal verification can come together to build the next generation of reliable AI-powered development systems. | Guest lecture by Rajdeep Mukherjee (Amazon) Bio: Rajdeep Mukherjee is a Tech Lead and Principal Applied Scientist at Amazon, where he leads the development of AI-powered developer tools, including Kiro and AWS Transform, shaping next-generation developer experiences both within and beyond Amazon. He holds a PhD in Computer Science from the University of Oxford, specializing in formal methods and program analysis for ensuring software correctness. Before joining Amazon, he worked in the Electronic Design Automation (EDA) industry, developing formal verification technologies for hardware, software, and safety-critical systems. He has also held research and engineering positions at Arm, Microsoft Research, IBM Research, and Diffblue. His research and engineering interests span AI coding agents, large language model applications, static analysis, program synthesis, and formal verification, with a particular focus on combining these techniques to build more reliable and trustworthy autonomous software development systems. |
| 08.12. | Common types of agents (ReAct, Plan-and-Execute, Reflexion, etc.) | Kummita |
| 15.12. | Multi-agent systems (incl. Agent2Agent protocol) | Bodden |
| 22.12. | Feedback through testing and symbolic methods | Bodden |
| 12.01. | Reliability and limitations | TBD |
| 19.01. | Security of agentic systems | Bodden |
| 26.01. | Solutions to challenges of agents across the various phases of the software lifecycle | Bodden |
| 02.02. | Human-in-the-loop, accountability, and code ownership: the changing role and competency profiles of software engineers | Bodden |
Exercise Sessions
Exercise session will be held on Monday every week.
There will be 6 exercise sheets published in PANDA, which will be graded two at a time after the second deadline of each pair (sheets 1+2, 3+4, 5+6).
Exercise sessions will introduce each newly released exercise sheet and discuss the results of the previous assignment sheet.
They will also discuss labs.
A tentative schedule will be uploaded soon.
Abstract
Since the emergence of generative AI (GenAI), and particularly since the use of GenAI within agents, software engineering (SE) has been undergoing a radical transformation that raises many questions: In which phases of SE can GenAI be deployed effectively? What are the opportunities, but also the limitations and pitfalls involved? How does GenAI change the competency profile that will be expected of software engineers in the future? In this course, the use of GenAI and agents across the various phases of the software lifecycle (requirements analysis, implementation, testing, etc.) is discussed, made tangible through hands-on experience, and — where appropriate — critically examined. We will also cover current research on AI-driven software development methods. In practical exercises, students are introduced to current technologies that enable or simplify the design and deployment of agents in software engineering.
Evaluation
Final exam:
TBC
Syllabus
Topics covered include:
- Fundamentals of generative AI (concise recap as a starting point)
- Retrieval-Augmented Generation and agents: how each works and how they differ
- Economic perspective: productivity effects (empirical studies), cost, latency, and model economics
in production agent deployment - Knowledge and context engineering for SE tasks: providing repositories, issues, tests, and documentation as context (information curation, context windows, repo maps, RAG over
codebases) - Tool use and function calling: interfaces between agents and development tools (compiler, test runner, linter, debugger, version control), and standards such as the Model Context Protocol (MCP), Agent Client Protocol (ACP)
- Common types of agents (ReAct, Plan-and-Execute, Reflexion, etc.)
- Multi-agent systems (incl. Agent2Agent protocol)
- Benefits and challenges of agents across the various phases of the software lifecycle (requirements analysis, implementation, testing, etc.)
- Feedback through testing and symbolic methods (e.g., static analysis and verification) as a corrective and safety net
- Reliability and limitations: hallucinations, the out-of-distribution problem with proprietary codebases, correctness guarantees
- Security of agentic systems: prompt injection, autonomous execution, supply-chain risks from generated code
- Human-in-the-loop, accountability, and code ownership: the changing role and competency profiles of software engineers
Learning outcomes
After completing this module, students are able to
- explain how generative AI, retrieval-augmented generation, and agentic systems work and distinguish their respective areas of application in software engineering,
- apply current agent technologies to tasks across the software lifecycle and provide them with suitable context through repositories, tests, and tool interfaces,
- analyse the benefits and challenges of using GenAI and agents in the individual phases of software development,
- assess the reliability, security, and limitations of agentic systems, including hallucinations, the out-of-distribution problem, and correctness guarantees,
- design their own agent-based solution for a software engineering task and justify the architectural choices involved,
- evaluate the economic and organisational implications of deploying agents productively, including effects on cost, productivity, and the role of software engineers.