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. The course teaches one object, a coding agent, at three rising levels. In Apply you drive Aider against a permitted small model to specify and build a pair-programmer. In Analyze you take the human out of the loop: tools, an approval layer, an autonomous loop with stop conditions, and evals that measure what broke. In Create you grow that agent into an assistant you would actually use.

It is a hands-on software engineering course. Every phase ships working code, and all three grow one artifact: the pair-programmer you build in Apply becomes agent v0 in Analyze and the assistant you demo in week 15.

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, 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, approval and safety, evals, and system architecture. Those transfer to whatever ships next year. It also helps that half the term is spent building the agent rather than driving someone else's, and an agent you wrote does not go out of date on a vendor's release schedule.

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.

Apply is built on Aider, an open-source AI pair-programming CLI, pointed at any compatible endpoint serving a permitted model; Ollama is one hosting option. Aider comes first because it makes context, model, and prompt visible and controllable, which is exactly what the phase teaches.

Analyze drops a layer down: you call the chat-completions API directly and write your own agent, with a tool layer, an approval layer, and an autonomous loop. Create hardens that agent into an assistant. From Analyze on, the tool you use most is the one you wrote. No paid coding-agent subscription is required at any point.

Stage 1 permits qwen3.5:4b and qwen3.5:9b, with the 9B recommended, plus the announced course model during observed sessions. The same rule covers specification drafting and critique, diagrams, instructions, code, tests, and secondary models.

Changing providers does not authorize changing models. Other models require a published course-policy amendment. Preserve design and development sessions and disclose the actual model IDs and hosting in AI_LOG.md.

Everything you build talks to a model through one interface, the OpenAI-compatible chat-completions API. Local Ollama or llama.cpp hosting is one option; students implement YAML configuration so no provider is hard-coded. No vendor account is required to take this course.

Because it is one interface, any OpenAI-compatible endpoint works, including a hosted one. The hackathons run on a course-provided endpoint. CAEN machines provide the no-cost hardware fallback; compatible hosted services are optional and must serve permitted models.

No paid service is required. Local hosting needs no vendor account. A hosted service may require its own credential, stored outside git. The staffed Setup Lab in week 1, before the first lecture, gets you serving a model and running Aider against it in the room, with help. A second supervised window runs in week 2, ahead of the setup gate.

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

No. We assume you've used something like ChatGPT casually, nothing more. Apply teaches AI-assisted coding from first principles, and sixteen guided Aider lessons across weeks 1 and 2 bring everyone to the same baseline before the build starts.

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 prerequisite is EECS 281 and EECS 201, or ULCS standing, or instructor permission. 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 an 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)
• 6–8 hours: the guided lessons, then project work and debugging
• Three evenings across the whole term for the hackathons

Create 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, plus Ollama (or llama.cpp) to serve a model and Aider to drive it. The Setup Lab installs both with you in week 1.

Hardware: a laptop running macOS, Linux, or Windows with WSL that can serve a small model. No GPU required. If yours cannot, the CAEN lab machines are verified to run the course models and cost you nothing, and the staff can hand you a hosted endpoint instead. Tell us in week 1.

Cost: $0. No textbook, no required LLM spend.

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.

No. Instead there are three hackathons, in weeks 4, 7, and 15: single evening sessions with the whole cohort in one room, outside the scheduled lecture and lab times. 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.

Hackathon 1 is Thu Sep 24, the evening before the Apply build is due, so the work you do in the room is part of what you hand in. They are graded, and they are the one place the course watches you work.

If you cannot make an evening, for work, care responsibilities, or another class, arrange the makeup in advance. Extended time up to 150% happens in the room with everyone else, and anything beyond that gets a supervised alternate session.

Administrative 10% (lecture and lab attendance, taken with Poll Everywhere, plus any incentive bonuses), then Apply 18%, Analyze 22.5%, Create 49.5% — the three phases dividing the other 90% in a 20 / 25 / 55 ratio. Those weights are locked.

Within Apply: 25% the sixteen guided lessons, 25% the pair-programmer build, 50% hackathon 1. The Stage 1 build divides its own grade as 40% specification/diagrams, 40% behavior/verification, and 20% development evidence. Student tests earn explicit credit. See the syllabus and phase packets for the other splits. Nothing here is curved against your classmates; the grading scale is a guaranteed minimum that can only move in your favor.

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.

Yes, and it is 10% of your grade — the administrative bucket, split 60% lecture / 40% lab and scored separately. We take attendance with Poll Everywhere (mobile app or any browser), which checks that your response comes from the room.

70% attendance earns full credit on each: 20 of 28 lectures, 10 of 13 labs. Below 70% it scales in proportion. The eight-lecture, three-lab margin is the absence policy — illness, interviews, and travel come out of it, and you don't have to ask.

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

Labs: mandatory. Same check. Checkoffs happen in person, and missing a lab without prior approval scores zero for that checkoff.

What the incentive bonuses are, and how they interact with the 10%, publishes by the end of week 1 (Fri Sep 4).

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.

Nothing. There is no textbook and no required LLM spend. Local hosting or CAEN supplies a no-cost path. Compatible hosted services are optional; the course provides the endpoint for observed hackathons.

Cost is still course material, just not in dollars. You measure and report tokens, wall-clock time, and tokens per second per session, because those are what constrain an agent you actually run, and the evals in Analyze grade cost and latency alongside pass rate. You will start tracking it in Lab 01 with Aider's /tokens.