[One Million AI Engineer Special] How Stanford Teaches AI-Native Engineering — Mihail Eric, Monaco
Summary
- AI-native hiring raises the entry bar toward senior-level judgment. Mihail Eric tells Stanford students that “every company needs you, but the floor is much higher”: implementation is increasingly delegated, while architecture, system trade-offs, and understanding remain valuable. His response is apprenticeship through real open-source contributions, where maintainers teach judgment that agents cannot confer simply by generating code.
- Verification and maintained intent become the constraints as code generation accelerates. At “30 plus PRs a day,” traditional review makes humans the throughput ceiling, but indiscriminate merging defeats the purpose of engineering. Eric supports selective auto-approval grounded in verifiability; the hosts press the unresolved question of preserving a feature’s accumulated requirements across many individually plausible changes.
- A simple agent loop is easy to reproduce; reliable work across a large codebase is harder. Eric teaches a useful coding harness in 200 lines, then exposes production prompts through intercepted requests. The harder problems are research before implementation, allocating context across agents, and removing instructions as capabilities move into model weights—without letting automation displace understanding.
- Monaco’s differentiation rests on distribution, enriched data, and sales expertise alongside its agent harness. The Series B company targets seed-to-Series A customers before they become deeply attached to Salesforce, then aims to grow with them. Eric describes its “world database” of enriched companies, accounts, and contacts. The host illustrates buyer timing with a VP of sales changing jobs; Eric discusses finding the right buyer at the right time, but does not say Monaco relies on that specific signal.
- Vertical agent companies can win users first and backfill model economics later. Monaco initially used frontier models to discover what was possible and is now exploring open-weight models, post-training, and RL environments for cost and speed. Its engineering rule is “you buy to learn and you build to keep,” although Devin’s organic adoption internally shows that useful vendors can retain their place.
- Security automation leaves a gap between finding bugs and understanding what ships. The dependency debate cuts both ways: rebuilding components reduces outside exposure but concentrates undiscovered mistakes in private code. The hosts challenge the assumption that better models settle security, emphasizing sensitive data, billing, authentication, authorization, and the loss of awareness when generation outruns review.
- Gateway consolidation makes architectural sense, but buyers can preserve point solutions. Eric accepts that MCP portals and LLM gateways address overlapping governance problems; Swyx’s counterexample to his own bundling thesis is OpenRouter’s success through narrow model-routing focus. “You buy your org chart”: enterprise ownership and purchasing boundaries can outweigh the appeal of one unified platform.
- Software factories must prove themselves through products rather than orchestration activity. The conversation frames remaining human control around “intent” and “review,” while the hosts criticize systems whose principal output is more infrastructure for themselves. Their advice to students is to raise ambition toward projects such as a browser, or build rigorous benchmarks and evals; elaborate agent activity alone is a poor measure of progress.
Deep dive
1. The junior engineer’s floor is moving toward senior judgment
Eric conceived Stanford’s CS 146S, The Modern Software Developer, around November 2024, then spent roughly nine to ten months developing the proposal and curriculum. Its first offering was fall 2025, before “Opus 4.5, 4.6 days.” The second version reflects how much autonomous coding agents have changed the work since that first class.
The original course surveyed agents across the software development lifecycle: specification, implementation, review, and SRE. This version emphasizes principles Eric thinks are becoming more durable, particularly context engineering, architecture, and working in production codebases. His position combines teaching with practice as Monaco’s head of AI; guest lecturers supply frontier experience beyond his own.
This is explicitly not a beginner programming course or a replacement for computer science. Algorithms and other foundational classes are prerequisites. Eric wants students to understand how systems work and what their trade-offs are, then delegate more implementation details. His employment message is optimistic but demanding: “Every company needs you, but the floor is much higher.”
An entry-level engineer can no longer assume that performing at Google’s L3 level is sufficient, Eric argues; students should approach something closer to senior-level capability. Swyx’s deliberately provocative formulation—most students are “cooked,” while some become exceptionally valuable—draws attention to the distributional problem. The hosts acknowledge that Stanford students’ prospects do not answer what happens across the broader workforce.
2. Open-source maintainers become the missing apprenticeship
Last year’s structure combined nine assignments with an open-ended capstone. Eric’s example was giving students a repository, asking them to use an AI review tool, and judging its output. Those exercises became too easy: students could potentially “one-shot” them. In his informal classroom survey, everyone was using coding agents; he said nobody really types code by hand anymore.
The replacement puts students inside substantial open-source projects, including coding agents and tools serving agents. Contributions become coursework rather than optional extracurricular activity. The important change is encountering an existing system with real constraints: students must understand unfamiliar code, make useful changes, and satisfy maintainers who have reasons for accepting or rejecting an implementation.
Eric sees mentorship as the bridge between experienced engineers who acquire extraordinary leverage from agents and juniors who lack the underlying mental models. Maintainers review contributions and explain “good software,” passing on design judgment through actual work. Successful contributors may also get hired. The educational and recruiting mechanisms are connected: students demonstrate capability to the people evaluating their changes.
Access to compute should not become the limiting variable. Eric has arranged additional credits with participants including Factory, Cognition, and OpenAI, beyond ordinary educational offers. He does not want a “$20 a month subscription” to prevent students from exploring what is possible. The objective is to let them “token max something” when that produces a useful experiment.
3. A 200-line harness makes the agent loop legible
Eric strips a coding agent down to a model interacting with tools in a loop. A useful implementation that edits files can fit in about 200 lines and requires no more than Stanford’s introductory algorithms course, CS 106B. It lacks features such as sub-agents and MCP, but removes the impression that the core mechanism depends on inaccessible “secret sauce.”
Students then move from the miniature implementation to inspecting a production system. Using mitmproxy, Eric intercepts requests and responses to reveal system, planning, and compaction prompts. He says he used “Opus 5.5,” described as two days old. The progression matters: students begin as tool consumers, build the baseline mechanism, and then inspect what the real harness adds.
The hosts admit underestimating Claude Code early on: one query cost approximately fifty cents, provoking “Who’s gonna use this shit?” Eric recalls Boris’s instruction to build for where the model would be six months later. The subsequent improvement in models helped unlock long-running autonomy and substantially changed what belonged in the curriculum.
Harness complexity is a moving target. The hosts discuss system prompts around 20,000 tokens, an 80% reduction, and subsequent expansion and contraction. Eric highlights instructions for Git and task handling moving from prompts into model capabilities. Weaker models may need examples; stronger ones may be overconstrained by them. His preferred early design principle was “fewer tools do more,” using powerful tools such as Bash and SQL.
4. Context engineering requires research and selective memory
Eric finds that surprisingly few practitioners advance beyond vanilla prompting: “Do me the thing.” That can work until the agent meets an unfamiliar, million-line codebase. His workflow introduces research, alternative proposals, a human decision, and then a plan or specification before implementation and testing. The research stage deliberately establishes what the agent needs to know before it starts changing things.
Swyx’s unresolved problem is distributing that context across multiple agents. Should a sub-agent inherit the entire conversation or start separately? How much should its findings be condensed before returning? A review agent may need broad visibility across everyone’s work. “I don’t like anything I’m doing,” he says of the current techniques; one large specification does not solve coordination.
More context also introduces new errors. The host describes repeatedly expanding and contracting what agents receive: first they know too little, then they overfit to an incidental comment from earlier in the conversation. “They took it as the law.” Eric calls this among the areas that remain more art than science, requiring deliberate consolidation, refreshing, and attention to context bloat.
The hosts recommend accessible research into system-prompt changes and downstream effects of context management, without pretending every paper is definitive. Eric’s practical prescription is smaller than keeping up with every announcement: experiment for ten minutes a day. Re-solving a familiar problem with a new tool can reveal enough to close much of the knowledge gap.
5. Skills should preserve understanding while automating procedures
Eric distinguishes a tool call from a procedure. MCP can expose an external function or service; a skill codifies a repeatable sequence of actions in something like SKILL.md. The educational objective is to have students formalize those procedures themselves, rather than merely discover another collection of prewritten prompts to consume.
His preferred teaching examples include Matt Peacock’s “Grill Me” and Jeffrey Blitz’s “Explain Diff.” The latter produces a visual explanation of a change, then quizzes the developer about it. That final interaction is the point: skimming an attractive summary is different from demonstrating that you understand what happened. The skill makes the user participate in learning rather than only receiving generated output.
The hosts reject the equation between output volume and productivity. A one-line request can now generate tens of thousands of lines, leaving its author disconnected from the system. Their recurring principle is that there is no good situation for “turning your brain off.” Useful skills often ask more questions and force thought precisely because producing the implementation has become easier.
6. Skills create a maintenance problem of their own
Swyx argues that writing skills matters more than collecting influencer recommendations. Naive versions are often bad, including those generated by default skill-creation tools. He maintains a “skill cutter” that removes recurring weaknesses and excess material. The complication is that useful instructions can sit inside otherwise verbose output: editing requires preserving what actually changes behavior, not simply shortening everything indiscriminately.
The worst failure may be an unexpected trigger on an unrelated project. A broadly written description activates a procedure that was meant for one earlier task. Eugene Yan’s practice of pruning unused skills every few weeks offers one response. Swyx suspects some people at OpenAI and Anthropic would prefer skills to disappear; he presents that as speculation, calling giant collections of Markdown files a sloppy endpoint.
Another host’s counterargument is usability: people can obtain substantial value without opening those files, asking instead, “Look at the last five times we did this, make me a skill.” Eric distinguishes a potentially more durable purpose at Monaco: encoding organizational knowledge for Devin review, including preferred API construction and service boundaries. That is different from saving an arbitrary recurring prompt.
7. Monaco starts before Salesforce becomes hard to displace
Monaco is an SF-based Series B company building an all-in-one, AI-native sales platform. Its initial customers are early-stage startups, primarily seed through Series A. Eric’s wedge is meeting teams while they still track pipeline in a Google spreadsheet, then growing with them. Pulling an established enterprise away from Salesforce is a much harder starting point.
The company spent more than a year in stealth building toward an integrated offering, rather than beginning with a narrow sales point solution. Eric says they have learned a lot about the all-in-one over the last year and a half and are now going more upmarket. He likens the distribution model to companies such as Brex: start with emerging businesses and expand alongside them.
Monaco’s proprietary harness powers sales workflows including TAM and ICP scoring, ICP definition, pipeline changes, meeting preparation, and summaries. Its enriched “world database” covers companies, accounts, and contacts. The host illustrates buyer timing with a VP of sales changing employers, potentially making that a better moment to propose a sales platform. Eric says demand combines identifying the right buyer and the right time, but does not say Monaco uses that specific job-change signal.
The company uses Parallel and Exa, which Eric declines to rank, while also doing its own enrichment. He locates additional differentiation in forward-deployed account executives, or FDAEs: salespeople who help customers onboard and build workflows. Monaco is codifying expertise from its own GTM team, including former Brex personnel. Without that domain knowledge, he concedes, the offering would be more commoditized.
8. Vertical agents can backfill their model economics
Eric’s starting point for vertical AI is frontier models as external services: first discover what is possible. Cost and speed become more important as the product matures, motivating open-weight models, post-training, and RL environments. Monaco is now in that phase. He references debate over Harvey’s +50% versus -50% margins as a prompt to examine economics, explicitly setting aside whether those numbers are right.
Swyx calls this the “agent lab playbook”: begin with users and a product, use whichever models are necessary, then “backfill the model side.” Model labs approach the market from the opposite direction, starting with pretraining and seeking users afterward. The relationship remains complicated because a foundation-model supplier may also compete with the vertical application it serves.
9. Monaco buys to learn and builds around its infrastructure
Monaco’s background-agent platform, Monocoder, is built on Coder at coder.com and adapted to its internal needs. Eric describes isolated environments, support for multiple agents, and long-horizon coding tasks. It fills a role similar to Ramp Inspect. His preference emerged from the fit with Monaco’s existing cloud infrastructure rather than a general insistence that every engineering tool must be proprietary.
Its Slack-based agent, Hal, spans AI SRE, customer success, and QA. It helps debug problems and open corrective PRs, while salespeople use it to understand product behavior. That breadth creates a practical design question: the same underlying system needs different “personalities” when answering a developer and when explaining something to a salesperson.
Eric corrects himself to state the governing rule: “You buy to learn and you build to keep.” External tools help a team discover what it needs; internal systems become attractive when available offerings are immature or poorly matched. He stresses that Monaco remains willing to revisit vendors. Code review is an important exception where it continues to find outside software useful.
The first review-tool evaluation examined real PRs, comment categories, verbosity, and utility; no vendor crossed the threshold. A later trial of Devin spread because engineers requested access themselves. The hosts challenge whether this was merely “vibes”; Eric distinguishes the earlier structured analysis from the later organic adoption. He did not want to force another rollout after the first unsuccessful evaluation.
10. Agent readiness begins with ordinary engineering foundations
Eric treats agent readiness as a prerequisite for parallel agents, background systems, and factories. Before launching tens of agents, a team needs a codebase they can understand and verify: sensible structure, boundaries, documentation, and feedback. He credits Factory for articulating the category early. The report or dashboard is useful, but the underlying engineering conditions are what make subsequent automation possible.
At some companies, the constraint is less glamorous: backed-up merge queues, slow CI/CD, or excessive time to stand up an application. “The answer is not even always just more agents.” Another SRE bot does not remove a systemic infrastructure problem.
AI SRE becomes more compelling with enormous dependency graphs, Kubernetes infrastructure, and scattered Helm files. Eric praises Resolve and Night Shift, illustrating enterprise complexity with Ford- or Walmart-scale organizations. The hosts describe tens of thousands of repositories, sometimes more repositories than developers, with departed authors’ code still “load bearing.” Smaller systems may remain manageable enough to build internal assistance.
Resolve previously supplied a class sandbox with multiple services and planted bugs, letting students act as on-call engineers investigating through its agent. The wider objective is closing the loop: agents should inspect build logs and, ideally, production analytics. The hosts puncture elaborate trigger terminology by noting that much of it ultimately runs through cron jobs, while preserving the importance of runtime feedback.
11. Thirty-plus daily PRs make review the throughput constraint
Once agents can produce “30 plus PRs a day,” traditional review makes the developer the bottleneck. Eric rejects both being the compulsory gate on every change and letting anything merge. The question is how to retain justified trust while allowing the generation gains to flow through the rest of the system. Otherwise, “what was the point of generating at scale?”
Thoughtful architecture and verifiability can make some classes of changes suitable for auto-approval, Eric argues, without claiming everything qualifies. For the remainder, teams must decide whether humans should examine every line, the specification, or another representation. He broadly agrees with Ankit from Aviator’s argument for eliminating conventional review, but identifies another choke point alongside it: deciding what should be built.
Monaco invests in detailed PR descriptions that function as condensed specifications, including file-level pointers and the boundaries being changed. A one-paragraph summary is insufficient. Eric distinguishes this implementation record from the issue’s earlier specification. The hosts also observe that review activity is not growing in line with merged PRs, reinforcing the pressure to change what review means.
12. A local PR specification cannot preserve the whole system’s intent
The hosts’ pushback is that an internally consistent PR can still violate accumulated requirements. A feature is the sum of many changes, not just the latest implementation description. A model may reverse something deliberately introduced five weeks earlier. Humans become the “spec gods” who remember why it existed; instructions to maintain that broader understanding have not reliably solved the problem for the host.
A host points to Basis, the accounting company, as an example of version-controlling different artifacts for different purposes. One records intended future behavior; another captures the “canonical state of the code,” including otherwise implicit knowledge. Eric acknowledges the example, while the host presents it as a potentially useful approach—not proof that the industry has settled how to preserve specifications and implementation together.
Swyx describes an exploratory “program database” that he may never ship. It would capture traces, make specifications persistent objects, manage attached skills, and support greater concurrency than Git’s locking patterns. His objection is representational: code alone is too narrow a source of truth when assumptions, constraints, intent, and many agents’ work also need coordination.
He thinks Linear could win because it already holds tasks and intent. Eric broadens the possibility: B2B products collecting customer feedback or analytics may become coding-agent companies by closing the loop into product changes. Linear, Amplitude, Decagon, or a CRM could potentially turn an observed problem into action: “Here’s what’s broken. Go close the loop.”
13. Dependency removal trades outside exposure for private mistakes
In the security discussion, a host highlights Semgrep, an established security company that has augmented its offering for agents, and stresses dependency tracking and supply-chain discipline. The practical instruction is basic but consequential: pin dependencies appropriately, and do not arbitrarily run npm install while assuming the entire chain is trustworthy. Autonomous actions and abundant generated code expand the surface requiring attention.
Eric poses the possibility that the most secure codebase has no dependencies. The host agrees and extrapolates that cheap code could make building everything internally seem safest. Eric then pushes back: that statement is dangerous, because a team could make its own mistakes instead of relying on others to discover them. A package with 100,000 users has many opportunities for someone to find a flaw, whereas a company’s own users may never identify or report the equivalent problem.
Eric’s qualification is that open source itself may change. He believes most OSS repositories, “if not all of them,” will become agent-run software factories, citing Warp’s terminal as an example of the direction. If fewer people inspect each contribution, the historical argument for broad human scrutiny becomes less straightforward. Whether the resulting codebase is more or less vulnerable remains unclear to him.
The hosts recount a Vercel proposal to port widely depended-on C and C++ software to Rust, probably for about $6 million, seeking faster and more secure implementations. They do not treat that as proof that models eliminate security problems. The host’s objection remains: what if generated rewrites introduce different bugs? Greater capability changes the failure modes without demonstrating that failures disappear.
14. Better bug finding does not guarantee awareness of what ships
Discussion of “Daybreak” and “Glasswing” turns to whether privileged defensive access and delayed releases can settle the security problem. The hosts doubt the timing logic: give defenders three months, and attackers might still spend six months probing afterward. Giving a cyber model to 100 priority organizations also creates 100 targets to compromise. These are objections to assuming the release sequence resolves the underlying asymmetry.
Another host emphasizes awareness over average bug rates: models may make fewer bugs on average, yet “you don’t even know what you’re putting out.” Developers increasingly neither write nor review everything they ship. Code scanning and security review remain relevant, but the loss of understanding is a separate problem from whether a model performs well on vulnerability detection.
Eric identifies data storage, billing, and authentication as especially sensitive areas and says, “Basically, don’t write code there.” A host affirms the concern, distinguishes authentication from authorization, and advises learning concepts such as AWS IAM before asking agents to implement them. As the host puts it, “Once you have the language, you can prompt for it.” Eric agrees that these conceptual foundations remain necessary despite implementation becoming easier.
15. Background agents turn nontechnical work into hidden codebases
The background-agent material extends beyond an IDE into asynchronous work, CI/CD, repository events, and operational triggers. Eric plans to use examples including Stripe Minions, Ramp Inspect, and Spotify’s internal system. He also praises Cloudflare’s adoption and write-ups as unusually strong for a public company of its size. The common question is how software teams make agents useful when nobody is actively prompting.
The hosts argue that coding agents already sit underneath apparently nontechnical products and workflows. Swyx runs SEO and AEO inside Codex because ongoing research requires scripts, stored data, and visualization. A marketer may never inspect the underlying code, yet a persistent, multistep workflow can still benefit from a codebase. The visible interface need not reveal the machinery doing the work.
Eric accepts that nontechnical use cases can be implemented through code, but separates that from the interface question. Does the developer enter through the consumer assistant, inspect its underlying computer, or move into a development environment? The hosts see convergence; Eric asks whether that necessarily makes one product the universal entry point. The conversation leaves the product boundary open.
16. Gateways bundle technically but sell through separate buyers
Eric remains positive on MCP as an existing standard, while the hosts distinguish that from confidence in MCP portals as a business. At scale, Eric sees a need for a central entry point covering governance, security, auditing, and cost optimization. His case is conditional on organizational complexity: the value becomes clearer when many tools and services require common controls.
Swyx argues that the portal folds into the LLM gateway, alongside authorization and billing. These are versions of the same architectural layer, the “God box” mediating between multiple users and multiple services. Eric accepts the consolidation argument, explaining that separating the terms in a curriculum is partly pedagogical. Combining related controls also lets them depend on each other in useful ways.
OpenRouter supplies Swyx’s counterexample to his own preferred architecture. It succeeds by focusing on model routing rather than also owning observability, operations, and MCP access. “I love being wrong like that,” he says: a narrowly defined product can sharpen engineering and marketing. Architectural overlap does not establish that one vendor should own every adjacent function.
Eric points to enterprise teams owning separate parts of the stack; consolidating endpoints requires agreement across those boundaries. Swyx translates that into “you buy your org chart” and “if it’s for everyone, it’s for no one.” Eric flags platform engineering as an increasingly important role, with responsibility spanning cloud infrastructure, developer experience, and security rather than a single application feature.
17. Factories still need intent, review, and a route into customers
The host frames the factory’s remaining human control as “intent” and “review,” with review likely to loosen before intent. Eric’s course framing similarly asks where humans remain, naming intent and verifiable systems. In his role analogy, a technical overseer understands enough constituent parts to set direction, metrics, and corrections. His 89% agent-written-code scenario is hypothetical; he says even frontier factory vendors claim “30 some percent, if even that” of fully agent-driven contributions. The hosts caution that dark-factory advocates have also publicly changed their minds.
Selling the whole factory is another matter. Eric thinks adoption probably has to be piecemeal: establish a coding agent, add background work or SRE, then connect the pieces. Simply dropping a complete factory onto Ford’s desk is implausible. The hosts suspect many companies want to build their own, making the boundary between infrastructure vendor and internal platform an unsettled commercial question.
They cite an OpenAI write-up describing five months building an internal tool with zero manually written lines. Its initial slowdown and subsequent offloading illustrate that harness engineering involves learning, not instant acceleration. Warp’s course partnership offers students another perspective: contribute to the factory and help keep it running, rather than only submit a conventional feature and leave.
Eric’s human-role analogy is a CEO who understands enough constituent parts to set direction, metrics, and corrections. The technical overseer similarly adjudicates product requirements and engineering constraints. The hosts resist declaring product and engineering roles immediately merged: Anthropic’s platform product and engineering leaders had recently answered “not yet” when asked about combining their jobs, despite increasingly overlapping work.
18. Orchestration becomes a trap when it produces only itself
The discussion of Steve Yegge’s Gas Town turns on the recalled criticism that “the only useful thing that was built at Gas Town was Gas Town.” The hosts treat this as a failure of accountability to real products. Elaborate orchestration, rising token expenditure, and apparent activity are not enough if the system mainly sustains its own development.
Swyx says he wants hires who have been through agent “psychosis” and emerged from it. He describes paying an employee’s salary and token costs while receiving little output and finding that feedback does not land. Eric wonders whether Gas Town was also ahead of its time or difficult to understand; the hosts counter that its manifesto and terminology helped spread the idea.
The Boris framework they examine distinguishes five team-adoption stages: gated, assisted, parallel, supervised autonomy, and AI-native. A host says the artifact describes Anthropic as being at stage three and trying to reach four; Eric jokes that this would make Boris himself stage four. That distinction matters: an individual power user’s workflow is not equivalent to an organization operating the same way.
“Dynamic workflows” offer one concrete advance beyond copying a parent agent into sub-agents. The system writes a task-specific harness on demand, then runs it to perform the work. Eric says Monaco has built a version for GTM use cases. The pattern is specialized executable orchestration, rather than assuming every delegated task needs another identical general-purpose agent.
19. The next cohort needs higher ambition and better measures
The hosts expect PR contribution or merge rate to look ridiculous as an engineering metric two years from now. But the replacement remains unresolved: revenue feels too distant, and customer satisfaction may measure product decisions more than code. Eric’s answer is to train toward holistic systems and product-engineering judgment, connecting a technical contribution to the wider thing being built.
For capstones, Eric uses YC’s requests for startups as prompts: “Go build a company.” Last year, a designer photographed notebook sketches and generated a working Vercel app; Eric thinks the work probably helped her get hired there. The hosts acknowledge that accomplishment while arguing that the bar has moved: turning a photo into an app is now much less ambitious than writing a browser.
Eric describes support for one-off experiments reaching a thousand-plus agents, making credits a way to test ambition and identify exceptional builders. Meanwhile, many companies remain at single ChatGPT calls or initial Cursor adoption. He is emphatic that this gap is larger than Silicon Valley assumes, leaving room for students who understand frontier methods to contribute meaningfully elsewhere.
The hosts’ proposed “week 11” is direct: “Make benchmarks. Make benchmarks and evals.” Rigorous engineering posts and useful evaluation work can open doors at frontier model and agent labs, and potentially become businesses. They cite SWE-bench as an undergraduate project from Princeton. The recommendation is to investigate one important problem deeply enough that other people can assess and use the result.