The AI Engineer YouTube channel recently passed one million subscribers. For a special episode, host swyx interviewed Mihail Eric — who teaches Stanford’s CS146S, The Modern Software Developer, and serves as Head of AI at Monaco — about what a contemporary software engineer should learn and how those lessons hold up in production.
Course origins and aims
According to Mihail, the course idea dates back to November 2024 and the first offering ran in fall 2025. CS146S is a ten‑week, practitioner‑oriented syllabus that assumes students already have basic computer science foundations (algorithms, data structures) and focuses on the skills required to apply AI and agent techniques in large, real‑world codebases.
The class emphasizes context engineering, verifiability, and architecture for handling complex tasks with coding agents rather than teaching introductory CS topics.
Homework and open‑source contributions
A notable change in the current run is a homework component that requires students to contribute to open‑source projects. Maintainers of those repositories review the students’ patches, forcing students to confront questions an agent alone cannot solve: does the maintainer want this change, why does the code behave as it does, and what might the patch break? Mihail explains this process as a way for junior engineers to learn from senior maintainers and to gain experience in real team workflows.
Practical exercises include agent skills like Geoffrey Litt’s explain‑diff, which turns a change into a visual walkthrough and quizzes the reader — a useful tool to test whether an agent’s automatic patch is actually understood by a human reviewer.
The ten‑week syllabus (high level)
- Week 1: Internals of coding agents and harnesses; build a minimal agent loop (Mihail demonstrates a ~200‑line harness).
- Week 2: Scalable context engineering, tool design, MCP patterns.
- Week 3: Skills and procedural automation (skill MDs, formalized procedures).
- Week 4: Customizing agents (configs, hooks, sub‑agents).
- Week 5: Agent‑ready repositories — making codebases verifiable, documented and consumable by agents.
- Week 6: Agentic code review; the review pipeline and verifiability as mitigation of review bottlenecks.
- Week 7: Security — new attack vectors, dependency and supply‑chain risks.
- Week 8: Background agents — long‑horizon, event‑triggered agents in CI/CD and production.
- Week 9: Team‑level infrastructure (LM gateways, MCP portals, platform roles).
- Week 10: Building the software factory, human‑in‑the‑loop choke points (intent and review).
Mihail notes that while some patterns are still emerging, context engineering, verifiability, and agent‑readiness already look like durable practices.
What Monaco buys and what it builds
Monaco evaluated code review products and converged on Devin (Cognition) for many use cases, but for background agent work it built custom workspaces and tooling tailored to its cloud setup. Mihail’s rule of thumb: “you buy to learn, and you build to keep.” In other words, buy vendor tools to explore and learn; build bespoke systems when you need to operate and maintain them long term.
Monaco’s internal tooling includes Monocoder (a Coder‑based environment for running multi‑agent, long‑horizon tasks) and Hal, a Slack‑integrated system that can act both as an on‑call/engineering aide (investigate a failure and open a PR) and as a sales‑facing explainer. Mihail emphasized that the same raw debugging output doesn’t serve both audiences and different summarizations are required.
Monaco also builds sales‑focused harnesses and workflows (scoring TAM/ICP, pipeline evolution, pre‑meeting notes, summaries) and is evaluating model‑hosting and in‑house models as costs and performance justify.
Code review as a bottleneck
The interviewers discussed how high adoption of AI can create a new bottleneck: code review. When teams can generate code rapidly (tens of PRs a day), humans become the gating factor. The community is exploring what can be auto‑approved, what needs human intent checks, and how reviews should change (from line‑by‑line to spec/verifiability checks). Several organizations have published posts and experiments on this topic; Mihail pointed to it as one of the most urgent operational problems in AI‑augmented engineering.
Security and dependencies
Security remains a major concern: AI‑generated code and new agent flows introduce different failure modes. Dependency management, pinning packages, and supply‑chain awareness are core mitigations. Mihail observed that the safest possible codebase (in a narrow sense) is one with fewer external dependencies, but acknowledged the tradeoffs: open‑source dependence brings more scrutiny and wider testing, while fully internal code can hide blind spots.
Multi‑agent design and context management
Scaling agents involves fanning out tasks to sub‑agents and then compacting results back. That raises tough questions about context inheritance, prompt bloat, and how to keep reviewers’ perspective consistent across fan‑out. Mihail and guests described this as part art, part engineering: effective abstractions and tooling are needed for sub‑agent orchestration and context refresh/compaction.
The software factory idea
Mihail framed an agent‑run repo as a precursor to a software factory: repositories and toolchains become optimized for agents, and agent workflows produce and maintain code. He stressed that today only a fraction of code is agent‑driven in most teams, and the human role is likely to shift toward intent specification and verifiable review rather than manual line‑by‑line editing. The conversation also covered platform roles (platform engineers, DevEx) as increasingly critical for building and operating agent‑driven workflows.
Practical advice for students and instructors
- Experiment daily: small, frequent experiments with tools drive learning.
- Contribute to open source and get maintainer review — it accelerates mentorship.
- Build benchmarks and engineering evals (these help get noticed by labs and employers).
- Learn holistic systems thinking (not just component skills) to be more valuable in teams.
Mihail also recommended that students who want to stand out build ambitious or system‑level projects (not just one‑click demos) and suggested publishing rigorous engineering writeups and benchmarks.
Closing observations
The interview tied classroom material to production practice: the updated CS146S syllabus tries to codify what practitioners already find useful — harness internals, context engineering, agent‑readiness, verifiability, and operational controls around review and security. Monaco’s experience illustrates the pragmatic blend of vendor tools and in‑house systems needed to run agent workflows at scale.
While many technical and organizational questions remain open (how much can be safely auto‑approved, how to represent intent across many PRs, what the future platform stack converges to), Mihail’s course and Monaco’s engineering choices offer a concrete, hands‑on roadmap for engineers learning to work in an AI‑native development world.
(This article summarizes the YouTube interview and associated show notes and timestamps provided by the episode.)
