How Stanford Teaches AI Coding Now
· Summarized
Key takeaways
- AI coding courses must be rebuilt quickly as model capabilities change; Mihail replaced roughly 80% of Stanford’s previous curriculum after Claude Opus 4.5 and Claude Code altered practical workflows.
- Students should make genuine open-source contributions and receive a zero for shipping unreviewed AI slop; reading every line of generated code remains essential.
- Research, planning, implementation, and testing still form a useful agent loop, especially when the workflow includes a detailed specification and independent verifiers.
- Reliable agent systems need deliberate memory, compaction, file-system or sandbox strategies, and mechanisms that prove outputs work through tests, browsers, screenshots, or recordings.
- Company traces are valuable because they capture customer and application interactions, but trace-based routing products face competition from simpler routing, prompt, and skill optimizations.
- MCP servers should expose high-level intent-oriented operations instead of mechanically mirroring low-level APIs, so agents can accomplish goals with fewer tool calls.
- Monaco’s agent advantage comes from combining a CRM-like system of record with go-to-market data, expert workflows, persistent memory, and a custom harness compiled from natural language into executable graphs.
Summary
Mihail Rebuilt Stanford’s Modern Software Developer Course
Mihail Eric says week five of Stanford’s ten-week “Modern Software Developer” course is underway, alongside a newsletter with the same theme. It is his second year teaching the course, but he discarded roughly 80% of last year’s material after model capabilities changed dramatically around November–December 2025, especially with Claude Opus 4.5 and the rapid adoption of Claude Code over the holiday break. The revised curriculum now covers agent harnesses, loops, software factories, automated code review and approvals, merge conflicts, DevOps, and preparing codebases for agents.
Students Must Make Real Open-Source Contributions, Not Slop
Instead of assigning invented exercises, Mihail arranged for students to contribute to major open-source repositories as homework. He jokes that maintainers may “love slop,” but says a student receives a zero if a maintainer complains about low-quality generated code. His students have strong computer-science fundamentals, but the course teaches them to onboard quickly to large repositories, understand architecture, scope issues, gather context, choose MCP tools, and use skills appropriately. The core rule is simple: students must read every line their agent produces rather than blindly merging its output.
Research, Plan, Implement, and Test Still Matter
Mihail pushes back on the idea that capable coding agents eliminate structured development. He teaches a version of the RPI loop—research, plan, implement, and test—which includes gathering context before coding, reviewing a reasonably detailed specification, and defining how outputs will be verified. The host connects this to Jesse’s popular Superpowers project, whose continued popularity after a year of rapid model advances suggests that disciplined agent workflows remain valuable. Mihail says the best use of his own time is setting up verifiers that can independently check what an agent has done.
Verification Is Moving Toward Visual and Browser-Based Proof
The host describes Jesse’s “prove it” skill, which makes an agent record a Loom-style walkthrough showing that the application works. Mihail says developers are also experimenting with more informative code diffs, including visual architecture diagrams inspired by older technical formats, plus screenshots and recorded flows. Playwright with MCP can provide browser-based checks, and a recently merged Web MCP debugging capability lets an agent operate on a web application specifically to diagnose problems. Mihail expects verification companies to expand into broader software factories because closing the loop requires understanding both upstream development and downstream validation.
Guest Lectures Show What Agent Work Looks Like at the Frontier
Mihail’s Stanford guests included Boris, the creator of Claude Code, and Lee Robinson, formerly a Cursor developer-relations executive and now at SpaceX. Boris described running perhaps thousands of agents and argued that a one-off prompt is a mistake: the agent should talk to a loop and prompt itself through meta-prompting. With no token-cost constraint, he experiments by intelligently brute-forcing difficult problems. Lee delivered a dense, 45-minute explanation of modern agent harnesses, covering computer use, context engineering, tool calls, subagents that simulate infinite context, and compaction.
Proactive Assistants and the Challenge of Memory
The conversation compares products such as Grok bots, Instinct, and Dots. The host finds Instinct substantially more proactive—for example, asking how a movie was—while Dots mainly surfaces potentially useful information from email. Lee explained that agent systems use file systems, regularly compact conversation state, and write information out so it can be retrieved at the right moment. The speakers also discuss new approaches to agent sandboxes and file systems, along with efforts to replace or rethink Git. Anthropic has even published work on rebuilding version control because conventional platforms struggle with the volume and reliability demands of agent-generated commits and pull requests.
Why AI Startup Pitches Keep Converging on Traces
Mihail says he hears one or two startup pitches a week and stops paying attention when the same idea keeps returning. A common pitch adds JavaScript to an application, traces model requests and responses, and routes each task to a cheaper specialized or open-weight model. He agrees that companies want to keep increasing usage without allowing token costs to rise, but says routing and prompt or skill optimization can address costs without another layer of software. He calls company traces “the new oil” because they capture customer and application interactions, while warning that the category is difficult to differentiate.
Monaco Turns Go-to-Market Expertise into Agents
At Monaco, Mihail leads development of agents for go-to-market work, including pipeline reviews, total-addressable-market building and segmentation, demand-generation recommendations, and outbound campaigns. Monaco combines CRM functions, data enrichment, and outbound workflows, then uses emails, meeting recordings, transcripts, Slack messages, uploaded collateral, and public announcements to infer an organization’s tone, ideal customer profile, target buyers, pain points, and relevant timing. Its “Monaco memory” is a persistent store of what the system knows about an organization and its users. Rather than being purely self-serve, every customer gets a forward-deployed account executive to help configure the system.
A Custom Harness Compiles Intent into Sales Workflows
Monaco has built its own go-to-market agent harness, while outsourcing undifferentiated infrastructure such as micro-VMs to Vercel sandboxes. Natural-language instructions are converted into an intermediate representation, effectively JSON or YAML describing a workflow, then compiled into a graph that can loop and self-heal. Mihail says the defensible pieces include the data and context layers, memory, compaction, tools, and Monaco’s position as both system of record and system of intelligence. MCP tools should be designed around agent intent rather than one-to-one API endpoints: a meeting-search tool, for example, should support both keyword and semantic queries through one meaningful entry point.
Show notes
What does it take to build AI agents that deliver useful, reliable work?
Stanford lecturer and Monaco Head of AI Mihail Eric joins Demetrios for a conversation inside a Waymo about how AI is changing software development - and what it takes to put agents into production.
Mihail explains why he rebuilt most of his Modern Software Developer course, how he teaches students to avoid shipping AI slop, and why research, planning, and verification still matter as coding agents become more capable.
They discuss Claude Code, agent loops, context engineering, memory and compaction, and how to design MCP tools around what an agent needs to accomplish. Then they go inside Monaco’s approach to sales agents, from turning meetings and emails into useful insights to building a custom agent harness.
Along the way: lessons from Boris and Lee Robinson’s guest lectures, why company traces are becoming valuable assets, and Monaco’s unusual approach to brand building.
What’s the biggest bottleneck in your agent workflows: context, tools, or verification? Let us know in the comments.
Timestamps:
[00:00] Meet Mihail Eric
[00:16] Teaching AI Coding at Stanford
[02:42] Avoiding AI Slop
[04:48] Research, Plan, Build, Test
[06:19] Verifying Agent Work
[09:16] Lessons from Claude Code’s Creator
[12:40] Proactive AI Assistants
[16:13] Agent Memory & Context
[17:41] Rethinking Git for Agents
[19:32] AI Startup Pitches
[22:51] Why Traces Matter
[24:09] Better MCP Tools
[26:01] Monaco’s Sales Agents
[29:40] Turning Conversations into Insights
[33:33] AI Meets Human Expertise
[35:03] Poker & Brand Building
[36:46] Inside Monaco’s Agent Stack
[38:44] Designing Tools Around Intent
[40:12] Building an AI Advantage
[42:53] Wrapping Up
Follow this show on AudioBrevity and new episodes get summarized for you. Create a free account