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; the few details marked TBD are announced by Sep 5.

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 to week 4) 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 take the human out of the loop: tools, an approval layer, an autonomous loop with stop conditions, and the evals that measure what broke when you left the room. In Create (weeks 8–15) you grow that agent into an assistant you would actually use.

The course is relentlessly hands-on and runs on models you serve yourself. A small model punishes sloppy engineering visibly; that is the point, not a budget compromise.

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. /03Build an autonomous agent: real tool use, an approval layer, a loop with stop conditions, and an eval suite that measures it
  4. /04Measure and harden an agent: edit formats, prompting the harness, permission policy, context management, regression gates
  5. /05Design and ship a working assistant: persistent memory, design-first method, a webserver, and a channel beyond the terminal

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 to end of week 4 · 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 Lab 02Supported build time, staff in the room L07LLM APIs: Opening the Client You Were Handed L08Tool Use, Function Calling, and the Agent Loop Analyze spec released Mon Hackathon 1 · Thu Sep 24 evening Build due · Fri Sep 25
Analyze

Take the human out of the loop

Weeks 4–7 · L07–L14 · Labs 03–05 · 22.5%
WeekLab (Mon / Tue)Tue lectureThu lectureMilestones
Wk 5Sep 28 – Oct 2 Lab 03Build the agent: tools, function calling, and the loop L09Stop Conditions and the Approval Layer L10Serving a Local Model: an Overview Week 5 ends with an agent that runs
Wk 6Oct 5 – 9 Lab 04Leave the room, then measure what that cost L11Edit Formats, Measured Against Your Own Parser L12Prompting the Harness
Wk 7Oct 12 – 16 Lab 05The eval harness, then harden v0 until it passes L13Evals: Task Suites, Pass Rate, Cost and Latency L14Guardrails and Failure Modes Hackathon 2: the gate attempt · date by Sep 5 Analyze due · end of week 7
Create

Grow it into an assistant

Weeks 8–15 · L15–L28 · Labs 06–12 · 49.5%
WeekLab (Mon / Tue)Tue lectureThu lectureMilestones
Wk 8Oct 19 – 23 No lab · study break Mon + Tue Fall study break · no class L15The LLM Wiki and OKF; RAG as the Alternative Build the wiki
Wk 9Oct 26 – 30 Lab 06Build the wiki: ingest / query / lint L16The Elephant-Goldfish Model as Skills L17Design Is the New Code
Wk 10Nov 2 – 6 Lab 07Build EGM skills for an existing coding agent L18Permission Policy and How It Fails L19A Repository That Tries to Prompt-Inject Your Agent
Wk 11Nov 9 – 13 Lab 08Harden the approval layer you built in week 5 L20Context Management and Compaction L21The Tool Interface; Why the Small Model Punishes Sloppiness
Wk 12Nov 16 – 20 Lab 09Context management when the window fills L22Sessions and Memory L23Capturing the Build: the Graded Evidence
Wk 13Nov 23 – 27 Lab 10Sessions and capture; make the baseline gate pass L24Testing Your Own Agent; Regression Gates Thanksgiving · no class
Wk 14Nov 30 – Dec 4 Lab 11Test your agent; regression suite L25Webserver and Channel L26Wiring the Wiki (Memory) and EGM (Method) Into Your Agent
Wk 15Dec 7 – 11 Lab 12The integration lab L27Deploy and Demo Craft L28Project Showcase + Course Wrap Hackathon 3 · date by Sep 5 Classes end · Fri Dec 11

Week 4 belongs to both phases on purpose: Apply's build is due that Friday while the lectures open the Analyze phase. Lecture titles in the back half may shift slightly as material is finalized. Dates won't.

04 What you build

One repository, one growing artifact

Everything you build from week 3 onward lives in one git repository: the pair-programmer becomes agent v0 becomes your assistant. Course materials are delivered to you as personalized GitHub repositories; hackathon work is submitted through PrairieLearn, and everything else 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–4 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 dueFri Sep 25
EffortRedesigned workload under review
FormatIndividual
  • All sixteen lessons, completion-and-effort graded — nothing is hidden and nothing is optional
  • Build rubric: 40% specification and diagrams, 40% demonstrated behavior and verification, 20% development evidence and reconciliation. No hidden suite.
  • Specification: requirements 10, architecture/interfaces 10, Aider increments 10, diagrams 10 (components 4, sequence 3, lifecycle 3).
  • Behavior and verification: functionality 20, behavioral tests 8, safety/recovery tests 7, integration/reproducibility 5.
  • Evidence: spec-first history 5, deliberate Aider use 5, diagnosis/reconciliation 5, operating instructions 3, disclosure/index 2.
  • 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 · Agent v0

The same repository, with the human removed: a tool layer (read, write, run) via real function calling, a manual approval prompt in front of anything dangerous, then rule-based auto-approval with a decision log, an autonomous loop with six stop conditions, and an eval suite that measures all of it. Week 7 ends with your agent completing a published gate task unattended.

ReleasedMon Sep 21
DueEnd of week 7
Effort22–27 hrs across 3 weeks
FormatIndividual
  • The gate task is published with the spec — tuning your agent against it is the assignment
  • Eval suite: at least eight tasks, each run at least three times, reported as pass rates
  • Closes with a teardown report on what your agent still cannot do, graded on the quality of the failures you found

Create · Wiki, design skills, a hardened agent, an assistant

Week 8: an LLM-maintained Markdown knowledge base (ingest / query / lint). Week 9: design-first skills for a coding agent. Weeks 10–13: harden v0 — permission policy, injection resistance, context management, sessions, regression gates. Weeks 14–15: wire the wiki in as memory and the skills in as method, add a webserver and one channel beyond the terminal, and demo the assistant you would actually use.

RunsWeeks 8–15
FinalFormat announced later in the term
Weight49.5% · the largest grade
FormatIndividual
  • Each stage lands through a scored baseline gate
  • Differentiation comes late and on purpose: weeks 14–15 add your channel and one capability from your own week-7 teardown list
  • Final deliverable format is announced during the term

05 Hackathons

Three nights of building with AI

Three hackathons. Everyone builds with AI in the same room, on a clock. The course provides the workspace so the evening goes to building instead of setup: browser VS Code with Aider, a course model endpoint, and your own repository already cloned. They count toward your grade, and they show whose work it is.

Hackathon 1 · Thu Sep 24

Week 4, the evening before your build is due: new work on the codebase you are about to hand in, from a prompt revealed in the room.

Hackathon 2 · week 7

Your week-7 gate attempt itself: a room full of people watching their own agents run unattended, and learning whether their auto-approval rules were any good. Date announced by Sep 5.

Hackathon 3 · week 15

The last observation: your finished assistant, live. Date announced by Sep 5.

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 40/40/20 rubric
  • 50% of Apply · hackathon 1
22.5%

Analyze

  • Agent v0 against the week-7 gate
  • The eval suite and measurements
  • The teardown report
  • Hackathon 2 (the gate attempt)
  • Exact split published in week 1
49.5%

Create

  • Baseline gates per stage: wiki, skills, hardened agent
  • The final assistant
  • Hackathon 3
  • 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
  • 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.

Hackathons run on a course-provided endpoint in PrairieLearn — nothing for you to set up or 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. 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.