Questions, answered

"A two S E." Two A's up front (Applied Agentic), then Software Engineering. We write it AASE and say it out loud as A-two-S-E.

Building software with AI agents, treated as a serious engineering discipline. You progress through three phases: working effectively with AI coding tools (Aider, Claude Code, Codex), scripting your own agents against LLM APIs, and designing a production-grade agent orchestrator as your capstone.

It is a hands-on software engineering course. Every phase ships working code.

No, it builds on them. Traditional SE courses teach you to design and build systems yourself. This course teaches you to direct AI agents that write code, and to build the systems those agents run on. The fundamentals still matter; you'll lean on them constantly.

The tools are current (Aider, Claude Code, Codex, MCP), and the course gets revised every offering. The deeper bet is on fundamentals that outlast any single tool: context management, tool use, the agent loop, delegation, evals, and system architecture. Those transfer to whatever ships next year.

Python, plus fluency with the shell and git. Projects assume you can pick up new libraries on your own; there are no tutorials on basic syntax. If your Python is rusty but your fundamentals are strong, you'll be fine.

Phase 1 is built on Aider, an open-source AI pair-programming CLI. It comes first because it makes context, model, and prompt visible and controllable, which is exactly what the phase teaches. Claude Code and Codex arrive in week 3.

Phase 2 drops a layer down: you call LLM APIs directly and write an agent from scratch, then extend Claude Code with slash commands, hooks, sub-agents, and MCP servers. Phase 3 is your own system; you choose the stack within project requirements.

In phase 1 with Aider, we limit you to older, less capable models on purpose. Weaker models demand the focused, involved human interaction the phase is designed to teach.

Phases 2 and 3 open up tool and model use. Use, understand, document, excel.

The course supports multiple providers: Google Gemini, OpenAI, and Anthropic, plus OpenAI-compatible endpoints and local models (via Ollama or LM Studio).

Phase 1 pins specific models for Aider (see above). From phase 2 on, your projects must work with at least one provider; supporting more than one is encouraged.

Not yet. Week 1 includes detailed setup instructions: which providers, which plans, and how to handle keys securely. Don't spend money before then; we'll point you at the cost-effective options.

No. The capstone exists so you learn what is under the hood of those frameworks. Utility libraries are fine (httpx, sqlite3, a CLI toolkit), but the orchestration logic, the agent loop, state, delegation, and evals must be yours.

No. We assume you've used something like ChatGPT casually, nothing more. Phase 1 teaches AI-assisted coding from first principles, and the self-study packet in week 1 gets everyone to the same baseline with Aider.

No. This is a software engineering course, not an ML course. You won't train models or derive gradients. L02 covers how LLMs produce code at the intuition level, and that is all the theory the course needs.

What you do need is strong coding skill (hence EECS 281) and the ability to learn libraries quickly.

Yes. The course moves fast and assumes you can debug complex systems and read unfamiliar code without hand-holding. If you have equivalent experience from elsewhere, contact the instructors about a permission override.

It's a 4-credit course. Expect 12–15 hours per week on average:

• 3 hours: lectures (Tue/Thu, 3:00–4:30)
• 2 hours: lab (Mon 3:30–5:30 or Tue 12:30–2:30, your pick each week)
• 1–2 hours: daily micro-learning
• 6–8 hours: project work and debugging

Phase 3 runs hotter, especially near the final demo. Budget for some 15–20 hour weeks late in the term.

Software: Python 3.11+, git, a code editor, and LLM API access (setup guidance in week 1).

Hardware: any modern laptop running macOS, Linux, or Windows with WSL. No GPU required; everything runs against hosted APIs.

Cost: expect to spend $100–200 on API costs across the semester.

The course is not open to auditing while it is experimental (EECS 498). Anyone is free to attend lecture up to room capacity, and a limited amount of course material may be available online.

Final demos run in week 15 (Dec 8–10). Each student gets about 30 minutes with the staff to:

• Demo the orchestrator live (with a recorded backup, because demos)
• Walk through key design decisions and tradeoffs
• Answer technical questions about the implementation
• Present eval results and the cost report

Think of it as a technical interview about something you built. If you built it and understand it, you'll be fine.

They're short, about 5–10 minutes: show a TA your work, answer a couple of questions, done. They exist to keep you on pace, not to trip you up. If you're not finished, come anyway; partial progress you understand beats a no-show every time.

No. All three projects are individual work. You may discuss concepts and debug together, but every line of code, every prompt, and every report you submit must be your own.

AI use is required. Understanding is what gets graded. You must:

• Understand every line you submit
• Document the tools, models, and prompts you used
• Explain your code in lab checkoffs and the final demo

If you can't explain how your code works, that is a problem, and it is the one thing this course is designed to catch.

Lectures: mandatory. They're built around live demos and discussion.

Labs: mandatory. Checkoffs happen in person. Missing a lab without prior approval scores zero for that checkoff.

Talk to the staff immediately. Each phase builds on the last, so falling behind compounds fast. We can adjust timelines for documented emergencies, and office hours exist precisely to un-stick you early.

Cost management is course material, taught from week 1:

• Use cheaper models for development and iteration
• Cache responses while debugging
• Set rate limits and budget alerts in your provider dashboard
• Track spend per task (you'll do this in Lab 01 with Aider's /tokens)

Early weeks are very cheap: think phases 1 and 2 for the cost of a pizza. Phase 3 may cost as much as an engineering textbook, depending on the tasks you attempt, your model selection, and your use of rate limit and budgeting controls.