Stanford’s CS146S The Modern Software Developer now treats coding agents as the default, not a cheat code to ban. In a November 8 Latent Space interview, Mihail Eric—adjunct professor and head of AI at Monaco—walks through a refreshed syllabus where students one-shot last year’s homework, so new assignments push them into open-source maintainer review, explain-diff quizzes, and harness internals. At Monaco he applies the same lens: buy Devin to learn, build agent workspaces to keep, and design Hal so sales and engineering get different answers from one investigation stack.
For builders, the episode is a state-of-the-art course map tied to production constraints—not a university press release.
When last year’s homework becomes one prompt
Bounty board with pinned cards for open-source maintainer review assignments
Image: explainx.ai
Eric traces the course from a 2024 idea through a fall 2025 run in the pre–Claude 4.5 era. By the second offering, he surveyed sophomores and juniors: everyone already coded with agents. Exercises that once took a week—like running an AI code reviewer on a repo and critiquing its feedback—became afternoon tasks.
His response is to move assessment upstream of the diff:
- Open-source contributions where a maintainer judges fit, style, and breakage risk.
- Skills such as explain-diff (Geoffrey Litt) that turn patches into visual walkthroughs plus quizzes.
The pedagogical bet: agents make typing cheap, so grades must test judgment, communication, and systems reasoning—the same shift in our AI homework penalty data and house rules for AI assignments.
Try Eric’s classroom trick on your team: run explain-diff on an agent-authored PR and note which quiz answers require reopening files. If nobody can pass without the IDE, you have a comprehension gap, not a velocity win.
Syllabus map: agents, harnesses, context, skills
Show notes on Latent Space link the public CS146S site and the assignments repo (linked from the episode) for contrast with the prior run. Topics named in the episode and notes include:
| Module theme | Practitioner takeaway |
|---|---|
| Build a coding agent | Tool loop, permissions, stopping conditions |
| Claude Code internals | Harness responsibilities beyond the model |
| Context engineering | Large-repo retrieval and noise control |
| Skills for understanding diffs | explain-diff and related patterns |
| Code review at scale | Faros stats on PR volume versus review time |
| Authority maps (Basis) | Where agents read prior decisions and intent |
| Background agents | Stripe Minions as production reference |
| MCP portals | Infrastructure convergence for tool hosts |
If you teach or manage juniors, compare this list to your internal onboarding. Missing harness and context weeks is how teams accumulate agent slop in legacy code.
Monaco: buy to learn, build to keep
Half-open core box illustrating buy-to-learn versus build-to-keep agent stacks
Image: explainx.ai
Eric’s day job grounds the theory. Monaco evaluated code review products and kept Devin for learning velocity, but built custom agent workspaces because reproducing production failures requires their cloud topology, secrets layout, and service graph.
He names Hal: engineers ask for investigations and PRs; sales asks how the product works. Same retrieval core, different answer shapes. That split is underrated in agent RFPs that ship one chat UI to every role.
His quip—“You buy to learn, and you build to keep”—is a useful procurement filter in 2026’s crowded agent market. It parallels how we advise readers on agent sandboxes: rent isolation patterns, own the integration glue.
Code review, security, and the software factory thesis
The conversation does not declare review dead. It cites Faros-linked stats (merged PRs up sharply while review time grows) and spends time on permissions, dependencies, and on-call loops when agents touch production paths.
Eric also points to open-source repos becoming agent-run software factories—maintainers as the bottleneck that decides what merges. That is why CS146S sends students to real maintainers instead of synthetic autograders.
For security parallels, pair this episode with Meta Project OT incident rates and 0rwx Unix levels for vibe-coded risk. Education and ops must move together.
AI Engineer CODE context
Latent Space frames the interview as prep for AI Engineer CODE in San Francisco and celebrates one million subscribers on the AI Engineer YouTube channel. Treat that as event marketing, but the syllabus links and Monaco architecture notes are durable references.
Classroom and team actions this month
- Diff quizzes: adopt explain-diff or similar on every agent PR in training repos.
- Maintainer externships: partner with one OSS project for mentored patches.
- Buy/build ledger: list agent tools you rent for pattern mining versus systems you must own.
- Role-specific outputs: design separate templates for support, sales, and engineering agents.
- Review budget: if merge rate doubles, schedule review capacity explicitly—see AI brain fry.
Teams deploying agents without guardrails should read AgentBeam alongside curriculum updates—blocking dangerous tool chains matters as much as teaching loop design.
Episode deep cuts: Stripe Minions, Boris Cherny, MCP portals
Latent Space timestamps worth skimming even if you skip the full 115-minute video:
- Stripe Minions as a reference for background agents with environments—compare Monaco’s workspace build versus buying review tools.
- Boris Cherny’s five stages of AI adoption (named near the end) as a maturity model for staff who onboard at different speeds.
- MCP portals discussion tying infrastructure convergence to one host, many tools—relevant if your company standardizes on MCP security practices.
Eric also mentions Basis Authority Maps: agents need pointers for current behavior, past decisions, and intent. Without that map, Hal-style systems re-litigate rejected features—exactly what maintainers prevent in OSS homework.
Assignments that survived versus assignments that died
Eric is explicit that nine assignments and a capstone from the first run shrank because models ate them. Survivors skew toward:
- Patch negotiation with strangers on the internet (maintainers).
- Harness literacy (what the tool loop guarantees and what it does not).
- Security and dependency review when agents propose upgrades.
- Team adoption questions—how juniors join teams where seniors disagree on agent policy.
That mirrors workplace surveys in our Kristian Polsø piece: seniors disagree on where LLMs belong. Courses must teach how to disagree with evidence, not only how to prompt.
Monaco.com dispute and the airplane banner anecdote
The episode references a public dispute involving Monaco and an airplane banner—details are anecdotal color, not legal findings. The pedagogical point is that agent-native companies still face brand crises requiring human communication. Hal must not be the only voice customers hear when trust breaks.
Skills ecosystem named in show notes
Show notes link Geoffrey Litt explain-diff, Faros code review research, Claude Code walkthroughs, and EO Studio’s earlier Mihail Eric interview. Treat those as primary reading alongside CS146S PDFs:
- Read explain-diff README and run it on one agent PR.
- Skim Faros charts before you promise “10x merges with zero review cost.”
- Watch Eric’s harness walkthrough before assigning students to build agents from scratch.
Our GitHub trending coverage of benjitaylor/skills and Claude animated shorts skills shows the same explosion of teachable agent artifacts CS146S tries to curate.
Designing your own “Modern Software Developer” week
You do not need Stanford registration to copy the structure. A one-week internal bootcamp might look like:
| Day | Theme | Deliverable |
|---|---|---|
| 1 | Tool loop literacy | Diagram your agent host’s permissions |
| 2 | explain-diff on a real PR | Written answers without IDE |
| 3 | Context engineering | Map repo folders to retrieval rules |
| 4 | Maintainer drill | Tiny OSS patch or doc fix externally |
| 5 | Security review | Threat-model one agent automation |
Capstone: Hal-style dual audience—same retrieval, two output templates for engineering and customer success.
Measure success by post-course review time, not lines generated. If review balloons, you reproduced the Faros pattern Eric cites.
Faculty and tech-lead FAQ
Do we ban agents in exams? Eric’s approach bans only naive exercises. Use open-book agents with authentic assessment—maintainer review, live defense, or diff quizzes.
Which model should the course standardize on? The syllabus links harness concepts portable across Claude Code, Codex, and Cursor; pick one host for grading scripts but teach loop invariants, not vendor shortcuts.
How do we handle students with unequal API budgets? Pair campus credits with local open models for homework; reserve cloud spend for capstone weeks—see MLX local guides.
What if maintainers ignore student PRs? Eric’s pedagogy assumes maintainers exist; staff engineers should mirror that with internal mentors when OSS is not viable—otherwise students learn speed without merge discipline. Track time-to-first-review the same way you track time-to-first-byte today.
What developers are saying
The episode is fresh; HN threads are thin. Latent Space comments and workshop audiences reportedly focus on whether universities can keep pace with agent releases—a question CS146S answers by rotating assignments, not banning tools. Subscribe to syllabus diffs the way you subscribe to semver changelogs. Assign one engineer each quarter to diff CS146S against your internal academy and propose one new lab module with maintainer or mentor review.