Modules¶

A module is the full written version of a lecture topic. The deck is the fast version you see in class; the module is the one you read when you want more than the deck, or when you missed the hour.

Reading a module is optional unless the schedule says otherwise. The schedule is also where you find out when each topic is taught, and it links that week's slides and reading directly.

Modules go up as they are written, in the order the course teaches them, so this list grows through the term.

Published so far¶

SE and What AI Changes · slides: What is left for a software engineer when the agent can write the code. Places a task on the delegation boundary, and sizes an unfamiliar problem in twenty minutes well enough to defend it against the agent's version. Also the life-cycle models (waterfall as Royce actually wrote it, incremental and iterative, spiral, the Unified Process, Scrum and Kanban) and where this course's method sits among them.
The AI-Augmented Team · slides: Set your team up so the work is legible to every member, including the one that forgets everything between sessions. Put what governs the project in the repository, and make every unit of work traceable from requirement to merged code.
Professionalism · slides: Run a team problem the way you run a defect: observe the behavior, analyze its impact, investigate before you assume, and agree on a fix with an owner and a date. The standards themselves are on the Professionalism handbook.
Requirements as the Contract · week 3 slides · week 4 slides: Find out what your client actually needs, and write it down so your team and your agent build the same thing. Running a first client meeting, business objectives and success metrics, the project glossary, and the scope line you will need in October, and use cases an agent can build from. The nine kinds of requirement are in Requirement Types. Business rules, quality attributes, and the specification are still being written.
Context Engineering · slides: Assemble, for one unit of work, the context an agent cannot infer out of the specification you already wrote, and tell whether you supplied enough by measuring what got built rather than how good the prompt felt. How big the context window really is, how an agent finds code, managing a session that fills up, and why you cite the specification instead of copying it.
Software Architecture, Just Enough · slides: Decide, before the code exists, the few things that will be expensive to change, and let the quality attributes your client cares about choose them rather than the feature list. Architecturally significant requirements, C4 context and container diagrams, dividing a system by domain, one deployable or several, writing a decision down, and the trust boundary.
Design-of-Record · slides: Design one use case area before anyone builds it, at the depth where an agent no longer has to guess anything that matters, and get it approved by a teammate who did not write it. The challenge loop, sequence and state diagrams, the API contract, decisions and design patterns, the test list before the code, the questions test, and choosing a proving slice by risk.
AI-Assisted Implementation · slides: Estimate the human hours a use case costs, never the agent's minutes: a coarse range by planning poker when it is written, a refined one sized from its design's test list once the design is approved, and each next estimate made better from the hours your weekly activity reports logged. Then build the approved design with an agent in steps you can read: run the tests first, commit the trunk before the leaves and read it at the pause, deny the agent your secrets and check every dependency it names, treat existing code as evidence rather than authority, write a logging rule the agent will follow, run several agents only where their decisions are already on the record, and package a workflow your team has done by hand as its own command.
Code Review · slides: Review a pull request against the use case and test list it claims to implement, not only its diff. What review finds and what a rubber stamp costs; reading the trunk and the security rule in full and the leaves through their tests; a short checklist; labeled comments and when to approve; the author's half; and an agent as first reviewer, given the contract.
Reliability · slides: Turn an availability or performance requirement into an objective you can measure, make every call across a network fail the way your specification says, and learn from a failure without blaming whoever was at the keyboard. Fault, error, and failure; indicators, objectives, and error budgets; timeouts, retries, isolation, and degradation; and the blameless postmortem.
Observability and Debugging · slides: See inside a running system well enough to answer a question you did not plan for. Logs, metrics, and traces with Spring Boot Actuator, Prometheus, Grafana, and Zipkin, and Application Insights in production; when a collector pulls and when the app pushes; what each number misses; turning an SLO into a measured value; management endpoints as attack surface and health checks as a design decision; and debugging a production failure with an agent from evidence, not the symptom.
Requirements Traceability · slides: Keep a use case honest end to end, forward (is it built and tested?) and backward (why does this code exist?), and see why that matters more, not less, when an AI writes the code. Before a requirement changes, list what the change will touch. Then place every use case in the release it ships in.
Testing · slides: Write the test list before the code, and read every test, yours or the agent's, for what it actually checks. A test as inputs plus an oracle; partitions and boundaries; JUnit 5 and given/when/then straight from a use case extension; Mockito, and when a real object beats a mock; breaking the code once; which layer (unit, integration, end to end) a rule belongs on; and what coverage does not tell you.
Static Analysis · slides: Add analyzers to a codebase you did not write, triage what they report, and make them a gate for new code, the agent's included. The ladder from compiler to container scan; SpotBugs, PMD, and ESLint read by rule; real, false positive, or not worth it, each recorded with a reason; a baseline that only shrinks; JSpecify and NullAway; CodeQL, Dependabot, and pinning the tools you trust.
CI/CD and Continuous Deployment · slides: Get every change from a laptop to a running system the same way every time. Continuous integration as a habit; what a build ships, from JAR to container; a GitHub Actions workflow read job by job; a ruleset that makes checks block; continuous delivery and continuous deployment; build once and promote to staging; rolling back code and data; secrets, forks, and an agent in CI; reproducible builds, release tags, and feature flags.