AASE AASEEECS 498 · Fall 2026

EECS 498-016 Fall 2026

Syllabus

One object, three verbs: you Apply a coding agent, you Analyze one, you Create one. 28 lectures, 13 lab sessions, 3 evening hackathons, no exams. Dates follow the official UMich Fall 2026 calendar; details marked to be announced come in class. Revised Oct 22 to match the course as it has run since Lab03.

01 At a glance

CourseEECS 498-016 · Applied Agentic Software Engineering
Credits4 · upper-level CS technical elective
TermFall 2026 · Aug 31 – Dec 11
LecturesTue + Thu · 3:00 – 4:30 PM · LCSIB 2365
LabsMon 3:30 – 5:30 (GGBL 2153) or Tue 12:30 – 2:30 (DOW 1005) · identical content · attend either
AssessmentProjects, labs, hackathons · no exams
PrerequisitesEECS 281 and EECS 201 · or ULCS standing or instructor permission
LanguagePython · plus the shell and git
Contacteecs-aase-staff@umich.edu

02 Description

What this course is

AASE (say it "A two S E") teaches software engineering with AI agents in the loop, around one constant object: a coding agent. In Apply (weeks 1–3, build into week 6) you use one, using Aider with a permitted small model to specify and build a pair-programmer of your own. In Analyze (weeks 4–7) you open real coding agents and take them apart: how Claude Code, Codex and Aider load skills, guard against failure, reach the shell, MCP and the browser, and hand work to subagents, while your project extends your own private copy of Aider toward an agent. In Create (weeks 8–15) the tour of harness features continues and you build on an existing harness rather than from scratch.

The course is relentlessly hands-on. Apply runs on models you serve yourself, because a small model punishes sloppy engineering visibly. From Lab03 you work with Codex on model credit the course provides, inside a codebase far larger than anything you would write from scratch.

By the end of the semester, students will be able to:

"Understanding is what gets graded here, not generation. If you can't explain it, you didn't build it."

  1. /01Drive an AI coding tool effectively against a permitted model on a compatible endpoint, and reason about failures with the Big Three: context, model, prompt
  2. /02Specify and build a pair-programmer from a specification, with your own endpoint client, architecture, and tests
  3. /03Explain how a production coding agent works inside: the loop, tools, skills, approvals, context and caching, memory, and the model behind it
  4. /04Design changes to a large real codebase with a written design that survives a fresh-context review, then build them with a coding agent
  5. /05Build on an existing harness, and decide when to write your own loop instead

03 Weekly schedule

Fifteen weeks, calendar-anchored

Lectures meet Tuesday and Thursday, 3:00 to 4:30, in LCSIB 2365. Lab runs once a week with two sections covering identical content: Monday 3:30 to 5:30 in GGBL 2153 or Tuesday 12:30 to 2:30 in DOW 1005, and you can go to either. Labs meet before that week's first lecture and cover the previous week's material. Three calendar breaks shape the term: Labor Day (Mon Sep 7), fall study break (Mon–Tue Oct 19–20), and Thanksgiving (Wed–Fri Nov 25–27).

Apply

Use a coding agent

Weeks 1–3, build into week 6 · L01–L06 · Setup Lab, Lab 01 · 18%
WeekLab (Mon / Tue)Tue lectureThu lectureMilestones
Wk 1Aug 31 – Sep 4 Lab 00Setup Lab: serve a model, connect Aider · before the first lecture L01Course Intro + the AI Coding Landscape L02How LLMs Code (Under the Hood) Personalized repos delivered Tue
Wk 2Sep 7 – 11 No lab · Labor Day Mon Sep 7 L03The Big Three: Context, Model, Prompt L04Spec-Driven Development Setup gate + lessons due · Fri Sep 11
Wk 3Sep 14 – 18 Lab 01The pivot lab: how Aider works inside, hackathon briefing, the build reveal L05Modern Agentic CLIs L06From Pair-Coding to Agent Orchestration The pair-programmer build starts
Wk 4Sep 21 – 25 No lab · Lab 02 moved to week 5 L07Inside the Call: Messages, Streams, and Tool Calls L08Hackathon 1 Briefing Hackathon 1 · Thu Sep 24 evening
Analyze

Take real harnesses apart

Weeks 4–7 · L07–L14 · Labs 02–04 · 22.5%
WeekLab (Mon / Tue)Tue lectureThu lectureMilestones
Wk 5Sep 28 – Oct 2 Lab 02Hackathon 1 post-mortem, then Hackathon 1.5 L09Stop Conditions and the Approval Layer L10Skills and the Elephant-Goldfish Model
Wk 6Oct 5 – 9 Lab 03Where we are, and starting on Aider L11Guardrails: Errors, Retries and Approval Gates L12 · course feedback session Build due · Tue Oct 6
Wk 7Oct 12 – 16 Lab 04Reaching the computer: shell, MCP and the browser L13Browser Extensions and Assistants You Can Text L14Subagents
Create

Build on harnesses

Weeks 8–15 · L15–L28 · Labs 05–11 · 49.5%
WeekLab (Mon / Tue)Tue lectureThu lectureMilestones
Wk 8Oct 19 – 23 No lab · study break Mon + Tue Fall study break · no class L15Compaction and Prompt Caching
Wk 9Oct 26 – 30 Lab 05Building on Codex L16Agent Memory L17Knowledge Bases Hackathon 2 follows Lab 05 · date in class
Wk 10Nov 2 – 6 Lab 06To be announced L18Many Models, One Harness L19To be announced
Wk 11Nov 9 – 13 Lab 07To be announced L20To be announced L21To be announced
Wk 12Nov 16 – 20 Lab 08To be announced L22To be announced L23To be announced
Wk 13Nov 23 – 27 Lab 09To be announced L24To be announced Thanksgiving · no class
Wk 14Nov 30 – Dec 4 Lab 10To be announced L25To be announced L26To be announced
Wk 15Dec 7 – 11 Lab 11To be announced L27To be announced L28To be announced Hackathon 3 · date in class Classes end · Fri Dec 11

From Lab 03 the course moved onto Aider's own codebase and onto how production harnesses work, and the lecture topics from L10 on changed with it. Lab 02 moved from week 4 to week 5, so every lab after it runs one week later than first planned. Slots marked to be announced are not planned yet. Their dates won't move.

04 What you build

Three phases, real codebases

You work in more than one repository: the guided lessons, your pair-programmer, and from Lab 03 your own private copy of Aider. Each is delivered to you as a personalized GitHub repository, and project work is graded from your repository at the deadline.

Apply · Guided lessons, then a pair-programmer

Weeks 1–2 are sixteen guided Aider lessons in two parts: build a task manager's command line on a small model, then put a web front end on the same data. Weeks 3–6 you design and build the pair-programmer: all seven features plus YAML configuration. The template supplies only documentation and development tooling. You write a system specification, diagrams, and small implementation specs, then build your own architecture incrementally with Aider.

LessonsWeeks 1–2 · due Fri Sep 11
Build dueTue Oct 6
EffortRedesigned workload under review
FormatIndividual
  • All sixteen lessons, completion-and-effort graded — nothing is hidden and nothing is optional
  • Build rubric: 50% specification and design, 50% implementation and tests. No hidden suite.
  • Specification and design: requirements 10, architecture/interfaces 10, Aider increments 10, diagrams 10 (components 4, sequence 3, lifecycle 3), specs before code 5, what changed and why 5.
  • Implementation and tests: functional correctness 25, custom test cases 9, failure-path tests 8, end-to-end runs and live evidence 5, operating instructions 3.
  • Model disclosure and an evidence index are required but carry no points of their own: they are what makes the rest of the rubric checkable.
  • Tests earn credit for detecting plausible defects. A correct failing test can retain test credit. No points for suffering, and no repeated deductions for one shortfall across otherwise sound artifacts.
  • Submit the repository with system/increment specs, three diagrams, student-authored tests, YAML example, development and operating instructions, sessions, AI_LOG.md, and design reconciliation

Analyze · P2, Aider as an agent

On your own private copy of Aider, from Lab 03. Four parts, in order: skills Aider finds and loads when the model asks, a loop where the model picks its own tools, a shell tool behind approval rules you write, and an MCP client. Each part is designed with Elephant and checked with Goldfish before it is built, and the design is graded as heavily as the behavior.

ReleasedAnnounced in class
DueAnnounced in class
ToolsCodex, your Aider copy
FormatIndividual
  • Work you started in Lab 03 on the skill loader counts toward it
  • The full spec, rubric and dates come with the release

Create · Building on harnesses

The lectures keep taking harness features apart (compaction and caching, memory, knowledge bases, many models), and Lab 05 shows how to build on an existing harness through the Codex app-server instead of writing your own loop. What you build in weeks 10 to 15, and how it is graded, is announced in class.

RunsWeeks 8–15
FinalFormat announced later in the term
Weight49.5% · the largest grade
FormatIndividual

05 Hackathons

Three nights of building with AI

Three hackathons. Everyone builds with AI in the same room, on a clock, with model access the course provides. They count toward your grade, and they show whose work it is.

Hackathon 1 · Thu Sep 24

Week 4: add AI to a supplied, working application, from a brief revealed in the room. It did not depend on your pair-programmer.

Hackathon 2 · after Lab 05

Follows Lab 05. Date and details announced in class.

Hackathon 3 · week 15

The last observation, of your final work. Date announced in class.

Makeup and accommodations

Everyone attempts at the same time where possible. The booked slot is two hours and the room stays open a third hour, so extended time up to 150% happens in the room with everyone else. If your approved accommodation needs more than that, a reduced-distraction setting, or a different time entirely, contact the staff in week 1 and we will arrange a supervised alternate session. If you cannot attend an evening for any reason — work, care responsibilities, another class — arrange the makeup in advance; you are not penalized for having a life.

06 Grading

Weight follows the work

Administrative · 10% Apply · 18% Analyze · 22.5% Create · 49.5%
10%

Administrative

Lecture and lab attendance, plus any incentive bonuses announced during the term. Attendance is taken with Poll Everywhere — the mobile app or any browser — which checks that your response comes from the room.

60% lecture, 40% lab, scored separately. 70% attendance earns full credit for each: 20 of 28 lectures and 10 of 13 labs. Below 70%, the component scales in proportion (your rate divided by 70%).

That leaves eight lectures and three labs of margin, and the margin is the absence policy — it is there for illness, interviews, travel, and the ordinary bad week.

18%

Apply

  • 25% of Apply · the sixteen lessons, completion and effort (includes the setup gate)
  • 25% of Apply · the Stage 1 build (4.5% of the final grade), under its 50-50 rubric
  • 50% of Apply · hackathon 1
22.5%

Analyze

  • P2, Aider as an agent: design and working behavior for each part
  • Exact split published with P2
49.5%

Create

  • The Create project, announced in class
  • Hackathons 2 and 3
  • The final
  • Split announced with the final deliverable's format

Weights are locked. The three phases divide the 90% that is not administrative in the ratio 20 / 25 / 55, which is where 18 / 22.5 / 49.5 comes from; phase rubrics are written in that 20 / 25 / 55 unit. Gates are scored, not pass/fail: the suite reports what fraction of the task your work completed, and that fraction is what you earn. You can run your own tests as often as you like before a deadline; there are no redo periods after one.

Grading scale

A+97–100
A93–96
A−90–92
B+87–89
B83–86
B−80–82
C+77–79
C73–76
C−70–72
D60–69
Fbelow 60

These thresholds are guaranteed minimums. Boundaries may move in your favor, never against you.

07 Policies

House rules

Academic integrity

AI use is required in this course; that is the point. Both the design and the behavior of the generated system are graded.

  • You must follow each phase's model/tool rules for specification work as well as implementation
  • You must understand every line you submit and be able to explain it
  • You must document your AI usage in each submission: tools, models, prompts
  • You may not copy another student's code, prompts, or reports
  • You may not submit prior-semester or external work without attribution
  • Lab checkoffs and the three hackathons are where we verify understanding, in person

Violations go through the College of Engineering Honor Code process.

Attendance

  • Lectures and labs are the administrative 10% of your grade — see Grading above.
  • Lectures: mandatory, and 60% of the administrative 10%. Built around live demos and discussion you can't get from slides. Poll Everywhere, app or browser, checked against the room.
  • Labs: mandatory, and the other 40%. Same Poll Everywhere check. Follow each lab's work instructions. Lab01 and Lab02 support the project and have no separate project-point submission.
  • 70% earns full credit on each, counted separately — 20 of 28 lectures, 10 of 13 labs. Below that it scales in proportion. The eight-lecture and three-lab margin is the absence policy.
  • Hackathons: mandatory, with a real makeup path — see the hackathon section above.

Late work

  • No late days and no redo periods. Work is due when it is due.
  • Projects: a late submission loses 10% per calendar day, up to 3 days; no credit after that
  • Submission is your repository at the deadline — we grade that snapshot. Hackathon work submits through PrairieLearn in the room.
  • Extensions: for documented emergencies, case by case. Ask before the deadline, not after.

Collaboration

  • All work is individual.
  • Discussing concepts and debugging together is fine in every phase. Sharing code, prompts, or reports is not.

Accommodations

Students with disabilities should contact Services for Students with Disabilities and share the accommodation letter with the instructors within the first two weeks of term. Hackathon accommodations are described in the hackathon section and cost you nothing to use.

Mental health and wellbeing

If you or someone you know is struggling, help is available.

  • Counseling and Psychological Services (CAPS): 734-764-8312
  • Dean of Students Office: 734-764-7420
  • Crisis Text Line: text HELLO to 741741

08 Tools + costs

What you need, what it costs

Required setup

  • A laptop running macOS, Linux, or Windows with WSL. No GPU needed.
  • Python 3.12, git, and a GitHub account
  • Ollama (or llama.cpp) to serve a local model, and Aider to drive it. The Setup Lab in week 1 walks you through both, in the room, with help
  • Codex CLI from Lab 03, with a U-M GPT Toolkit key the course provides
  • No paid subscription required; compatible hosting is optional and credentials depend on the service

Model policy

Stage 1 uses Aider with qwen3.5:4b or qwen3.5:9b, with the 9B recommended. The same permitted models apply to drafting and critiquing specs, diagrams, instructions, code, tests, and secondary models. Other models require a published policy amendment. The announced course model is permitted during observed sessions.

Any endpoint implementing the assignment's OpenAI-compatible Chat Completions contract may host a permitted model. Students implement YAML configuration for API base, model ID, named credential variable, budget, timeout, and temperature. No Ollama-specific API or hard-coded hostname belongs in the application. A different provider does not authorize a different model.

From Lab 03, Analyze and Create work uses Codex on gpt-6-luna through the U-M GPT Toolkit, and your copy of Aider runs on the same model. Each lab and project says which models it permits. The course provides model access for the hackathons, so there is nothing for you to pay for.

Budget

There is no textbook and no required LLM spend. The expected cost of this course is $0 beyond a machine that can run a small model; the Codex credit comes from the course. If your laptop can't, the CAEN labs can: their machines are verified to run the course models, and working from one costs you nothing. Tell the staff in week 1 so we know.

09 Resources

Repos and communication

Course materials

  • Everything you work on is delivered as personalized GitHub repositories, created for you after the week-1 Setup Lab
  • Bring a GitHub account to the Setup Lab; watch your email for the repository invitations and accept them
  • Course site: eecs498-aase.github.io

Communication

Lecture podcast and recordings

Lectures are recorded (CAEN capture and Zoom). Each lecture also gets two short companion episodes on the EECS AASE Podcast, rolling out from week 1 as lectures are produced: a Brief before class that teases where we're headed, and a Deep Dive after class that walks the full arc. Episodes are AI-generated audio, produced from course materials and de-identified lecture transcripts; no student is ever named or identifiable in an episode. Subscribe from the podcast page. Want something removed from an episode? Email the staff and we re-cut or unpublish it, no questions asked (unpublishing stops distribution; apps that already downloaded an episode keep their copies).

Acknowledgments

This course draws on ideas and materials from people we're grateful to: Dan Disler (IndyDevDan), whose Principled AI Coding series shaped the Apply phase's pedagogy; Paul Gauthier, creator of Aider; Andrew DeOrio, for early course concept work; and Suraj Rampure, for course design feedback.