EO StudioFrom Writing Code to Managing Agents. Most Engineers Aren't Ready | Stanford University, Mihail Eric
CHAPTERS
- 0:00 – 0:30
AI-native engineers: from writing code to managing multiple agents
Mihail frames a new class of “AI-native” engineer where AI becomes a core working language. The central shift is moving from individual coding to supervising and coordinating multiple agents effectively.
- •AI as a new “language” for modern engineers
- •A single developer increasingly acts as a manager of agents
- •More agents can worsen outcomes without strong orchestration
- •Multi-agent management is positioned as an elite skill
- 0:30 – 1:07
Why multi-agent orchestration is the “last boss” skill (and Mihail’s Stanford role)
He argues that properly handling many agents is an advanced, rare capability today. He also introduces his background leading AI at a startup and teaching Stanford’s "Modern Software Developer" course focused on AI across the SDLC.
- •Multi-agent coordination as a top-0.1% competency
- •Parallels between agent management and human management skills
- •Stanford course centered on AI across the software lifecycle
- •High demand for AI-focused education (rapidly filled enrollment)
- 1:07 – 1:42
The junior engineer squeeze: alarming job-search anecdotes
The discussion turns to what’s happening to junior software engineers, highlighting how difficult it has become to get responses or interviews. Mihail uses real anecdotes to illustrate the intensity of the market.
- •New grads applying broadly with minimal responses
- •Junior roles feel especially constrained
- •Signals a structural shift rather than isolated stories
- 1:42 – 2:42
The “perfect storm” behind today’s hiring market
Mihail breaks down three forces that converged to make entry-level hiring tougher: post-COVID overhiring, subsequent layoffs, and a larger pipeline of CS graduates. Together, these create fierce competition for junior roles.
- •2021-era hiring surge followed by large layoffs
- •Companies realizing they can operate with smaller headcount
- •CS graduate supply has grown dramatically over 10–15 years
- •Crowded market: laid-off talent plus more new grads
- 2:42 – 3:18
AI as a staffing lever: fewer hires, higher leverage expectations
He adds AI as the third contributor: employers reconsider headcount when AI can amplify output. New entrants, he argues, must pair fundamentals with “AI-native” fluency to stay competitive.
- •Employers weighing AI leverage vs adding headcount
- •Rising expectation: fundamentals + AI-native workflows
- •This generation becomes the first to face the shift at entry level
- 3:18 – 3:48
What defines a top AI-native engineer: strong fundamentals + agentic workflows
Mihail defines AI-native engineers as grounded in traditional CS and system design while being highly competent with agentic workflows. The emphasis is on using agents effectively, not just using tools casually.
- •Traditional foundations still matter (systems, algorithms, design)
- •Competence in agentic workflows is a differentiator
- •AI-native isn’t “prompting,” it’s orchestrating work
- 3:48 – 4:18
Scaling agents safely: build workflows piecemeal, not “10 agents at once”
He recommends expanding from one agent to many in a controlled, incremental way. The core idea is to isolate tasks, define boundaries, and add agents only when prior workflows are stable.
- •Start with one agent and master the workflow end-to-end
- •Split work into isolated, confidence-friendly tasks
- •Add a second/third agent only after success with earlier ones
- •Avoid copying extreme setups without prerequisite skill
- 4:18 – 5:49
Context switching as the hidden bottleneck of multi-agent work
Managing multiple agents requires rapid context switching: tracking what each agent is doing, diagnosing when they’re stuck, and reorienting quickly. Mihail likens it to classic people-management, where the best human managers often transfer well to agent management.
- •Agents act like “eager interns” needing oversight
- •Humans must jump between tasks without losing state
- •Knowing how to unblock agents is central to success
- •People-management experience translates into agent orchestration
- 5:49 – 6:49
Building an agent-friendly codebase: contracts, tests, and consistent truth
Mihail introduces the idea of an agent-friendly development ecosystem where agents can reliably interpret and change the codebase. Tests act as explicit “contracts” defining correctness, and documentation must remain consistent with the code.
- •Agent-friendly codebases minimize ambiguity for automated contributors
- •Tests are contracts; weak coverage means weak constraints
- •Readmes drifting from reality creates conflicting guidance
- •Consistency between code and docs reduces agent confusion
- 6:49 – 7:50
Preventing spaghetti code: compounding errors and making the base airtight
He warns that agents can magnify mistakes quickly—one misunderstanding can cascade into larger issues. The remedy is ensuring the initial codebase is robust: strong design, testing, linting, and style enforcement before scaling agent contributions.
- •Agents can compound errors faster than humans
- •Early misunderstandings can “double down” across iterations
- •Prioritize airtight fundamentals (design, build reliability)
- •Linting and style checks help enforce consistent contributions
- 7:50 – 8:38
Consistency in design patterns: reducing choice paralysis for humans and agents
Inconsistent patterns (two APIs for the same task) confuse agents and humans alike. A codebase with consistent design conventions makes it clearer what “the right way” is, improving contribution quality.
- •Multiple ways to do the same thing create ambiguity
- •Agents may choose the wrong API in inconsistent codebases
- •Even experienced humans would need to ask teammates
- •Standard patterns make automated contributions more reliable
- 8:38 – 10:57
From functional to incredible software: taste, the last mile, and experimentation
Mihail argues the difference between merely functional and truly great software is often “taste,” developed by pushing beyond requirements. He emphasizes experimentation as a core AI-native habit, citing fast iteration cycles (even rewriting systems frequently) and encouraging builders to find what works through hands-on trial.
- •“Taste” is developed by doing the extra work beyond the baseline
- •The last mile: robustness, depth, and expanded capability
- •Top students push projects into real products/startups
- •AI-native development demands continual experimentation and iteration
- 10:57 – 14:19
Why juniors still matter + teaser: allocating intelligence and AI-native orgs
Mihail explains why junior engineers can thrive: they’re less entrenched, more adaptable, and learn AI-native skills fastest, while CS training teaches systems thinking and problem decomposition. The episode closes with a preview featuring Rem Koning on “allocating intelligence,” embedding AI into products, and what happens when AIs collaborate.
- •Seniors can be resistant; juniors are more nimble and tool-open
- •CS builds transferable thinking: decomposition, debugging, iteration
- •Developers’ confidence to customize and fix systems is a superpower
- •Next episode: AI-native orgs, embedding AI into products, AI-to-AI collaboration
