🏫 The University of Michigan has put the full lecture materials for its new AI coding course on GitHub — eecs498-aase/materials — so anyone who wants to learn how to do software engineering with an agent can just copy the homework.

This is the official course repo for the school’s Fall 2026 EECS 498-016 “Applied Agentic Software Engineering” — lecture notes, labs, and in-class demo code, the whole set — with the course website at http://eecs498-aase.github.io.

The fun part is that the repo itself is a sample of an “agent at work”: look through the PR list and all thirteen PRs were opened by claude[bot] — editing lecture notes, rearranging slides, syncing upcoming assignment deadlines. The instructor is basically reviewing the agent’s output.

What’s in eecs498-aase/materials grows along with the course. Lectures are numbered L01, L02 and so on, each with a slides.md source file plus compiled pdf and pptx; the labs directory holds the companion exercises; the demos directory contains codebases that actually ran in class, such as a command-line note-taking tool and a meeting-transcript analyzer. There’s also an egm directory with five skills called the Elephant-Goldfish Model. Slides get published around each class session, so you’re picking up materials on the same cadence as the class.

If you want to systematically learn how to write code alongside an agent, this is probably the freshest set of public lecture materials around right now.

GitHub: https://github.com/eecs498-aase/materials

EECS 498 AASE: Applied Agentic Software Engineering

Source: https://eecs498-aase.github.io/ EECS 498-016 · Fall 2026 · University of Michigan

AASE· say it “A two S E”

One object, a coding agent, taken three ways across fifteen weeks. Use one to build one. Take the human out of its loop and measure what broke. Then grow it into an assistant worth keeping.

4 creditsTechnical elective

Tue + ThuLecture · 3:00 – 4:30

Mon or TueLab · 2-hour section

No examsProjects, labs, demos

01The premise

The job is changing. The curriculum should too.

Software engineers increasingly direct systems that write code, instead of typing every line themselves.This course treats that work as an engineering disciplineand teaches it like one: with theory, deliberate practice, instrumentation, and grading that rewards understanding over output.

You will spend the whole semester inside real tools. First you learn to drive a coding agent deliberately, and to diagnose failures using the Big Three: context, model, prompt. Then you drop below the abstraction and write your own agent against a raw LLM API, tool calls, loop and all. The back half of the course is where that agent grows a memory, a method, and a deployment, and becomes something you would actually keep.

Lectures run live demos. Labs are hands-on working sessions with checkoffs. Every project ships code that runs.

“The engineers we want to graduate canexplain why an agent failedand fix the system around it.”

02Three phases

Drive one. Take it apart. Build one worth keeping.

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

01Weeks 1–3, build into 6

Apply

Use Aider to specify and build a pair-programmer. Sixteen guided lessons come first. Then you design the architecture, write specs and diagrams, and implement all seven features plus YAML configuration from documentation and development tooling. Both design and working behavior are graded, including your tests.

• 6 lectures (L01 to L06)
• Tools: Aider, permitted models, compatible endpoints
• Pair-programmer due Tue Oct 6

02Weeks 4–7

Analyze

Take the human out of the loop and measure what broke. Call an LLM API directly, hand the model tools, and write the agent loop yourself. Then give it an approval layer, stop conditions, and an eval suite, so you can say what your agent does rather than guess.

• 8 lectures (L07 to L14)
• Tools: raw LLM APIs, your own agent
• Agent v0 due end of week 7

03Weeks 8–15

Create

Grow the agent into an assistant worth keeping. A wiki it can read, design skills it can run, hardening against the ways it fails, and a deployment. Coding agents all the way down: you use one to build one, then use that one to build the next.

• 14 lectures (L15 to L28)
• Individual, like every project here
• Showcase Thu Dec 10

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. There are no exams. Full detail on the syllabus.

03Outcomes

By December, you will be able to

1. /01Drive a coding agent deliberately, and explain every line you hand in.
2. /02Diagnose AI coding failureswith the Big Three framework: context, model, prompt.
3. /03Build a tool-using agent from scratchagainst a raw LLM API: messages, tool use, the agent loop.
4. /04Take yourself out of the loopwith an approval layer, stop conditions, and an eval suite that says what your agent actually does.
5. /05Treat the model as configuration, not a vendor, and serve your own.

04The stack

Real tools, current versions

Everything runs on a normal laptop, and the course costs nothing beyond it. No textbook, no API bill, no subscription. You serve a small model yourself with Ollama. If your laptop cannot carry it, CAEN does, in the labs or from your own machine.

aiderollama· qwen3.5llm apis· pythongit + githubpytest· evalsprairielearn

05Staff

Instructors

One address reaches all four:[email protected]

Office hours

Times and rooms live on the course calendar. Add it to yours so changes show up automatically.

Fall 2026 is under way

The course began Aug 31, 2026. Enrolled students: the syllabus and schedule are the source of truth for dates and policy, and Ed is where we reach you.

Read the syllabus