50.057 Modern Software Design Studio with Agentic AI
This course is a studio-based elective that explores how modern software systems are specified, designed, built, verified, and continuously delivered using disciplined, specification-driven workflows. The course emphasises Behaviour-Driven Development and Spec-Driven design as foundations for software architecture, treating behavioural descriptions, executable specifications, and type systems as first-class design artefacts. Students learn to leverage agentic AI coding tools to support specification interpretation, code generation, refactoring, and CI/CD workflows, while maintaining human judgement, accountability, and design intent. Through hands-on studio projects, students design and implement production-style CRUD APIs for large-scale systems, establish automated testing and deployment pipelines, apply type-driven development for reliability and evolvability, and incorporate formal methods techniques to reason about correctness and software verification. The course focuses on end-to-end software design practice, integrating intelligent development tools with principled engineering workflows to prepare students for building robust, scalable, and verifiable software systems.
Prerequisites
50.003 Elements of Software Construction
And one of the courses listed below:
- 10.014 Computational Thinking for Design (For AY2020 to AY2024) or
- 10.025 Computational Thinking for Design (For AY2025) or
- Algorithmic Thinking and Object-Based Abstraction (For AY2026 onwards)
Learning objectives
- Apply Behaviour-Driven Development for software design
- Apply Spec-Driven Development using Agentic AI Coding tools
- Check, critique and improve AI-generated code
- Create CRUD API for large-scale software system
- Establish CI/CD using Agentic AI toolchain
- Implement Type-Driven Development for reliable code generation and refactoring
- Apply Formal Methods Techniques for software verification
Measurable outcomes
By the end of this course, students should be able to:
- Write down user stories for software requirements derived from users and stakeholders through the use of design thinking methods.
- Create scenarios and step definitions using the given user stories for automated testing of software behaviour.
- Implement CRUD API using spec-driven development and agentic AI coding tools.
- Establish CI/CD to deliver sprint deliverable using agentic AI toolchain.
- Deliver complete user story on a cloud at every sprint period.
- Evaluate safety of AI-generated code and agents’ actions.
- Create guardrails and increase observability of AI-augmented workflows.
- Specify correct program behaviour.
- Prove the correctness of the given program implementation.
- Use formal semantics to reason about the soundness of proof rules.
- Create practical and efficient verified code.
- Translate text-based and UML-based specification into type-based machine-verifiable specification.
- Apply type-driven development to enhance agentic workflow with tool-based guardrails and executable documentation.
Topics covered
- Introduction to Statically Typed Language and Test-Driven Development
- Introduces statically typed programming languages and their role in ensuring reliability and maintainability. Students learn Test-Driven Development (TDD) principles, focusing on writing tests before implementation to guide design, improve correctness, and support continuous refactoring.
- Behaviour-Driven Development and Spec-Driven Development
- Covers Behaviour-Driven Development (BDD) as a method to translate user requirements into executable scenarios, alongside specification-driven development where specifications act as primary design artefacts. Students practice linking user stories to automated tests and system behaviour.
- Creating CRUD APIs and CI/CD with Agentic AI Tools
- Focuses on designing and implementing production-style CRUD APIs using specification-driven workflows. Students learn to integrate agentic AI tools for code generation and establish CI/CD pipelines for automated testing, building, and deployment.
- Program Verification and Weakest Preconditions and Strongest Postconditions
- Introduces formal reasoning techniques for software correctness, including weakest preconditions and strongest postconditions. Students learn how to specify and verify program behaviour rigorously to ensure correctness beyond testing.
- Introduction to Dependent Types
- Provides an introduction to dependent types, where types depend on values, enabling more expressive and precise program specifications. Students explore how dependent typing can enforce correctness at compile time.
- Type-Driven Development
- Covers type-driven development as a methodology where types guide program design and implementation. Students learn how to use rich type systems to create reliable, maintainable, and self-documenting code.