Mas­ter-Course: Agen­t­ic Soft­ware En­gin­eer­ing (ASE) WS 2026/27

Course num­ber and lan­guage

L.079.05705

The teaching language will be English. Questions in German will be permitted.

Pub­lic course ma­ter­i­al

Public course material is being made available on this page.

Re­gis­ter­ing and com­mu­nic­at­ing

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.

Lec­ture Sched­ule

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.

DateLecture topicLecturer
13.10.Introduction and course outlineBodden
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 lifecycleBodden
02.02.

Human-in-the-loop, accountability, and code ownership: the changing role and competency profiles of software engineers 

Bodden

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Ex­er­cise Ses­sions

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.

Ab­stract

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.

Eval­u­ation

Final exam:

TBC

Syl­labus

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

Learn­ing out­comes

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.