The University of Michigan AI Coding course is highly recommended! Have students build their own Coding Agent, let it work on its own, and then require them to write up clearly why it failed.

The course is EECS 498-016, Applied Agentic Software Engineering. I went through the schedule — a full 15 weeks, starting with Aider plus a local small model, then implementing Tool Call, Agent Loop, and permission approval yourself, and gradually adding Eval, Memory, Skill, and safety guardrails.

The most noteworthy part is the lab design.

Students have to design at least 8 test tasks themselves, run each one 3 times, and track success rate, cost, and latency — then seriously analyze the causes of failures.

The lecture notes, lab slides, and in-class demos are also being open-sourced progressively, with source code and PDFs, so much of the content can be followed hands-on.

This feels like a great fit for people who already use Coding Agents but want to truly understand agent engineering. Worth bookmarking, and worth setting aside time to work through it.

Course: https://eecs498-aase.github.io

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 thesyllabus (https://eecs498-aase.github.io/syllabus.html).

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 (https://eecs498-aase.github.io/syllabus.html)