More MLOps.community episodes

How Stanford Teaches AI Coding Now thumbnail

How Stanford Teaches AI Coding Now

Published 2 Nov 2026

Duration: 00:43:42

AI agent development, verification loops, and go-to-market automation are reshaping software engineering and sales strategies.

Episode Description

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 conv...

Overview

The conversation covers a Stanford course titled "The Modern Software Developer," now in its second year and fifth week. The instructor describes a major curriculum overhaul - roughly 80% of material was replaced after the release of Opus 4 or 5 in December - shifting focus toward long-horizon agent tasks, harnesses, loops, software factories, and fully automated AI code review. Students now complete open-source contributions as homework, working with designated issues from top open-source projects, and the course emphasizes context engineering, the RPI (research, plan, implement, test) loop, and MCP tool integration.

Guest lectures from Boris, creator of Clodger, and Lee Robinson, formerly VP of DevRel at Cursor and now at SpaceX, covered frontier agent practices and a 45-minute primer on modern agent harnesses, including computer use, context engineering, and compaction strategies. The discussion also touches on verification loops - using browser recordings, end-to-end tests, and visual schematics of code diffs - as a critical use of time for developers.

The second half shifts to Monaco, a go-to-market platform that builds AI agents for sales workflows. The team describes a homegrown harness that compiles natural language into an intermediate representation and then into a runnable graph, with emphasis on intent-based MCP server design, persistent organizational memory, and a Forward Deployed Account Executive onboarding model. Broader industry trends discussed include new Git alternatives, agent sandboxes, tracing as a data asset, and cost optimization through open-weight models.

What If

  • What if you designed your MCP server around agent intent instead of API endpoints?

    • Move: Refactor your MCP server to expose a single entry point per capability (e.g., "query meetings") that internally routes to keyword search or semantic search based on the agent's request, rather than creating separate tools for each API call.
    • Why Now?: The source notes that the V1 approach of one-to-one API translation for MCP tools is "the worst way to do it" because agents can operate at a higher level. Designing around intent reduces the number of tool calls and errors, making your server more efficient for agents.
    • Expected Upside: You could reduce token usage and latency by minimizing hops, and make your server more attractive to agent builders who value simplicity and performance. This could lead to better integration and adoption of your service.
  • What if you built a verification loop that forces your agent to prove its work?

    • Move: Implement a "prove it" skill that, after each agent task, automatically records a video walkthrough (like a Loom) showing the app functioning correctly, or runs end-to-end tests and smoke tests to validate the output.
    • Why Now?: The source emphasizes that setting up verifiers is "the best use of my time" and mentions Jesse's approach of having the agent create a movie to demonstrate functionality. This is especially important as agents become more autonomous and produce more code.
    • Expected Upside: You could catch errors early, reduce manual review time, and build trust in your agent's outputs. This could allow you to scale agent usage without sacrificing quality, potentially increasing your development velocity.
  • What if you used open-source contributions as a training ground for your agent?

    • Move: Assign your agent to contribute to real open-source projects as part of its training, using a framework that requires it to research the codebase, scope the work, gather context, and submit a pull request that passes maintainer review.
    • Why Now?: The source describes a course where students contribute to open-source repos as homework, with the instructor teaching "advanced context engineering" and how to onboard into code bases quickly. This forces the agent to handle real-world constraints like merge conflicts and code review.
    • Expected Upside: Your agent could learn to produce higher-quality contributions that are accepted by maintainers, avoiding "slop" that gets rejected. This could make your agent more capable in production environments and give you a portfolio of real contributions to showcase.

Takeaway

  • Read every line of code your agent produces before merging. The instructor's rule is explicit: "Read every line of code that your agent produces". Treat unreviewed agent output as a zero-grade assignment.

  • Design your MCP server around intent, not API endpoints. Collapse related endpoints into a single tool with multiple query modes (keyword, semantic) rather than exposing a one-to-one translation of every REST call.

  • Before launching a long agent session, write a spec that includes a concrete verification step - end-to-end test, browser check, or smoke test - so the agent can self-validate its output.

  • Use the RPI loop (research, plan, implement, test) as your default workflow. Gather context and research the codebase architecture before jumping into implementation, and ensure the plan is detailed enough to scope the work.

  • Compact your agent's context by writing intermediate state to file systems and reading it back at strategic points in the conversation, rather than relying solely on in-context memory.

Recent Episodes of MLOps.community

9 Nov 2026 My AI Agent Bought Me A Car

Hermes agent uses reinforcement learning and trace-to-environment synthesis to enable continual self-improvement, balancing token efficiency with inference-time steering for better agentic performance.

29 Oct 2026 From Slop Code to Software Factories

"Tandem biking in Amsterdam's chaotic cycling culture led to a critique of AI-assisted coding's flaws, particularly its tendency to produce unmaintainable, poorly structured code, raising concerns about long-term software reliability."

22 Oct 2026 Token Maxxing Is Over and Here Is What Comes Next

"AI in software development offers benefits but faces challenges like nonsensical outputs and over-reliance; smaller, controlled models like Sonnet improve adoption, while measuring ROI and human-AI collaboration are key to success."

15 Oct 2026 Agents Acting Safely on Our Behalf

"Web infrastructure must evolve to support AI agents securely, with protocols like WebMCP enabling safe, deterministic actions while accommodating diverse interaction methods and user control."

More MLOps.community episodes