Frequently Asked Questions

Projects use Python 3.11+ and TypeScript. We assume you're comfortable with object-oriented programming and can learn new libraries independently. If you're strong in one language but not the other, you'll pick it up quickly — but there won't be tutorials on basic syntax.

This course teaches you to build production-grade software systems that coordinate autonomous AI agents. You'll progress through three phases: mastering AI-assisted coding tools, scripting multi-agent workflows, and building a complete agent orchestrator from scratch.

It's a hands-on software engineering course focused on real systems, not theory or toy examples.

No—it complements them. Traditional SE courses teach you to design and build systems. This course teaches you to orchestrate autonomous agents that build and coordinate systems. You're learning how to work with AI agents, not replacing fundamental software engineering skills.

Think of it as an advanced elective that extends your SE toolkit into the agentic era.

The field is moving fast, but the course focuses on foundational principles that will remain relevant: task decomposition, delegation, evaluation, tool integration, and system architecture. We'll use current tools (Aider, hosted LLM APIs, local models), but the skills transfer to whatever comes next.

The syllabus will be updated each offering to reflect the latest best practices.

OpenClaw is an open-source, self-hosted gateway that connects chat apps (WhatsApp, Telegram, Discord, iMessage) to AI coding agents. It implements multi-agent routing, sessions, tool use, plugins, and memory — exactly the kind of production system this course teaches you to build.

OpenClaw serves as the reference architecture for the course. The concepts you learn — agent loops, tool registries, delegation, session management, multi-channel orchestration — are the same patterns that power OpenClaw. By the end, you'll understand how platforms like it are built and be ready to contribute to or create your own.

No. You don't need to install, run, or directly work with OpenClaw. It's the inspiration and reference architecture — not a required tool. You'll build your own systems from scratch using the same fundamental patterns.

That said, OpenClaw is open-source and free to explore. Studying its documentation and source code is a great way to see how the concepts from class map to a real production system.

No prior AI tool experience required. We assume you've used ChatGPT or similar tools casually, but Phase 1 teaches AI-assisted coding from scratch using the Context-Model-Prompt framework.

By Week 3, you'll be writing sophisticated prompts for multi-file code generation. By Phase 3, you'll be designing agent coordination systems.

No. This is a software engineering course, not an ML course. You don't need to know how transformers work, how to train models, or any deep learning theory. You'll learn everything you need about working with LLM APIs and building agent systems.

You do need strong coding skills (hence the EECS 281 prerequisite) and the ability to learn quickly.

Yes. This course moves fast and assumes you're comfortable with data structures, algorithms, debugging complex systems, and reading large codebases. If you haven't taken EECS 281 (or an equivalent course), you'll struggle to keep up.

Contact the instructors if you have equivalent experience from another institution.

Not yet. We'll provide detailed instructions in Week 1 about which providers to use and how to set up keys securely. If you want to experiment early, some hosted LLM providers offer free trial credits, but don't spend money before class starts. We'll help you choose cost-effective options.

This is a 4-credit course. Expect 12-15 hours per week on average:

• 3 hours: Lectures (Tue/Thu)
• 1-2 hours: Daily Micro-learning
• 2 hours: Lab session (once/week)
• 6-8 hours: Project work and debugging

Phase 3 (the final capstone) is more intensive—some weeks you might spend 15-20 hours. Budget accordingly, especially near milestone deadlines.

Software: Python 3.11+, Node.js/TypeScript, Git, a code editor (VS Code recommended), and access to an LLM API.

Hardware: Any modern laptop (Mac, Linux, or Windows with WSL) with an internet connection. No GPU required—all projects use cloud LLM APIs.

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

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

The oral defense happens during finals week (Dec 14-21). You'll meet with faculty for ~30 minutes to:

• Demo your final agent orchestrator
• Explain key design decisions and tradeoffs
• Answer technical questions about your implementation
• Discuss your evaluation results

It's like a technical interview for something you built. If you built it and understand how it works, you'll be fine.

Lab checkoffs are short (~5-10 minutes). You demo your work to a TA, answer a few questions, and get checked off. They're designed to keep you on track, not to stress you out.

If you're not done, you can still attend for feedback, but you'll need to finish by the next lab (with a 20% penalty). Always better to show up with something than to skip entirely.

The course is provider-agnostic. You can use:

• Hosted LLM APIs
• Local models (via Ollama or LM Studio)
• OpenAI-compatible endpoints
• Cloud AI platforms

Your projects must support at least one provider. Supporting multiple is encouraged and counts toward Phase 3 milestones.

In Phase 1 with Aider, we will limit models used to older, less capable versions to force more focused and involved human interaction.

Phases 2 and 3 tool and model use will be opened. Use → Understand → Document → Excel.

Cost optimization strategies (taught in Week 1):

• Use cheaper models for development/testing
• Cache LLM responses during debugging
• Use local models for iteration, cloud for final runs
• Set rate limits and budget alerts in your provider dashboard

Early weeks will be very low cost (think Phases 1 and 2 for the cost of a pizza). Phase three may cost as much as an engineering textbook (depending on tasks attempted, your use of rate limit control, model selection, budgeting controls, etc.).

No. Phase 3 is about building an orchestrator from scratch so you understand how it works internally. You can use utility libraries (e.g., httpx, sqlite3), but the core orchestration logic must be yours.

Using LangChain or similar defeats the purpose—the goal is to learn what's under the hood of those frameworks.

Phase 1: Individual work only.

Phase 2: Individual work only.

Phase 3: Individual work only. You may discuss high-level approaches with classmates, but all code and writing must be your own.

AI use is required and encouraged in this course. However, understanding is what's graded, not generation. You must:

• Understand every line of code you submit
• Document which AI tools you used (tools, models, prompts)
• Be able to explain your code in lab checkoffs and oral defenses

The oral defense (Phase 3) verifies your understanding. If you can't explain how your code works, that's a problem.

Talk to the instructors immediately. We can adjust timelines for documented emergencies, but each phase builds on the previous one—falling behind compounds quickly.

Office hours are your friend. TAs can help you catch up if you get stuck early.

Lectures: Mandatory. Lectures include live demos and discussions you can't get from slides.

Labs: Mandatory. Labs include in-person checkoffs with TAs. Missing a lab without prior approval = zero credit for that checkoff.