Course Overview

I am developing and teaching the course of Agentic Software Engineering, which focuses on teaching students to build agents for compiling complex requirements into software systems. Students learn both the underlying engineering principles and the practical workflow of building agentic software systems. The course combines lectures, team-based development, benchmark-driven evaluation, and iterative software evolution. ARC-Bench is used as the practical evaluation environment of the course.

CS3604 Offered for students in the School of Computer Science Shanghai Jiao Tong University.
CS4810J Offered for students in Global College Shanghai Jiao Tong University.

ARC-Bench for Teaching and Competition

ARC-Bench is used as the practical evaluation environment of the course. Students develop their own software agents and evaluate how well the agents can compile complex requirements into working software systems.

The benchmark is integrated into the teaching process so that students can observe measurable progress throughout the semester rather than only receiving a final project score. It also creates a common competition setting for comparing agent designs, requirement representations, testing strategies, and token efficiency.

Demo Track Early-stage onboarding and pipeline validation. Students make sure their agent can complete the full benchmark workflow.
Normal Track Main course benchmark. Students optimize software quality, requirement coverage, robustness, and development efficiency.
Competition Track Final competitive setting for comparing mature agents developed by different teams.
Visit ARC-Bench

Course Curriculum

The curriculum is organized as a progression of capabilities rather than a fixed week-by-week schedule. Students move from understanding modern software development to building, evaluating, and evolving their own software agents.

1. Foundations: Software Engineering in the Agentic Era

Build a shared understanding of software systems, LLMs, and the changing division of labor between human developers and coding agents.

  • Introduction to Agentic Software Engineering — from code generation to project-level software engineering.
  • Web Development from a Software Engineering Perspective I & II — frontend, backend, database, APIs, and system decomposition.
  • LLMs, Agents, and MCP — models, tools, context, agent loops, and environment interaction.
Heroes of AI Programming A special class on the people, systems, and ideas that shaped modern AI programming. Through representative systems and invited experiences when available, students study how leading researchers and engineers turn foundation models into practical programming tools, and what design choices make these systems succeed or fail.

2. Requirement Compilation

Treat natural-language requirements as engineering artifacts that can be compiled into explicit structures, executable constraints, and software implementations.

  • Requirement Compilation Principles — requirements, scenarios, constraints, and traceability.
  • Software Engineering Intermediate Representations — UI, data, database, API, and behavioral representations.
  • Test-Driven Development for Agents — compiling requirements into tests and using tests as executable specifications.
  • Agentic Compilation — orchestrating requirement analysis, design, implementation, and validation across a repository.

3. Engineering Reliable Software Agents

Move from a prototype coding agent to an engineering system that can be measured, maintained, and improved.

  • Version Control & Software Maintenance — Git, collaborative development, CI/CD, and software evolution.
  • Token Budgets and Agent Efficiency — context management, cost, decomposition, reuse, and evaluation under resource constraints.
  • Software Testing — functional testing, regression testing, GUI testing, failure diagnosis, and quality assurance.

4. ARC-Bench: Build, Measure, and Compete

Use ARC-Bench as a continuous feedback loop for developing the course project.

  • Team Formation — students build teams of up to three members and define their agent architecture.
  • Demo Track — establish an end-to-end runnable agent and obtain an initial ARC-Bench ranking.
  • Normal Track — improve requirement coverage, software quality, robustness, and token efficiency.
  • Competition Track — compare mature agent designs under a common competitive setting.
Milestone 1 · Demo Track Complete the benchmark workflow and obtain a valid ranking.
Milestone 2 · Normal Track Establish the team's first competitive baseline and iterate on measurable weaknesses.
Milestone 3 · Competition Track Submit the mature agent for final course competition and comparison.

5. Software Evolution in Practice

Evaluate whether an agent can continue engineering after the first version has been generated.

  • Mid-term Presentation — architecture, current benchmark results, limitations, and iteration plan.
  • Feature Enhancement Practice — evolve an existing system under new requirements.
  • Testing and Bug-Fixing Practice — reproduce failures, diagnose causes, repair the system, and prevent regressions.
  • Final Presentation — demonstrate the complete agent, engineering decisions, ARC-Bench results, and lessons learned.
Final agent code may be submitted within 10 days after the final presentation.

What Students Are Expected to Learn

By the end of the course, students should be able to design an agentic software engineering workflow that connects requirements, intermediate representations, implementation, testing, and maintenance. They should also be able to evaluate an agent quantitatively on ARC-Bench and reason about software quality, robustness, traceability, and token cost rather than considering code generation alone.