# How Stanford Teaches AI Coding Now

## Executive summary

The discussion explores the shift in software development toward agentic workflows, emphasizing that while AI agents are becoming highly capable, reliable production systems require structured processes. Key architectural components discussed include advanced context engineering, robust verification loops, and specialized agent harnesses. The conversation highlights the necessity of moving beyond simple API calls (V1 tools) toward designing tools based on semantic intent, and the critical role of persistent memory and data tracing in building sophisticated AI agents for enterprise use cases.

## Key takeaways

- The Importance of the RPI Loop: To avoid 'AI slop' and ensure reliable agent output, the process must incorporate a structured Research, Plan, Implement, and Test (RPI) loop. Agents should not jump directly into implementation but must first gather context and verify their outputs against end-to-end or smoke tests. (04:48, 06:19)
- Shifting from Tools to Intent: Modern agent design requires thinking beyond a one-to-one API translation (V1 tools). Instead, the system must be designed around the *intent* of the task (e.g., 'query meetings') to allow for multiple modes of data retrieval (e.g., keyword search or semantic search). (38:44)
- The Value of Traces and Memory: Company-level data traces (customer interactions, app-level requests) are becoming a valuable asset, acting as the 'new oil' for training and optimizing agents. Persistent memory stores (like an 'LM wiki') are crucial for maintaining context across long-running agent sessions. (22:51, 16:13)
- Agentic Workflows and System Boundaries: The trend is toward 'software factories' and fully automated AI code review, handling complex DevOps tasks like auto-approvals and merge conflict resolution. Companies are building proprietary agent harnesses to manage these complex, multi-step workflows. (09:16, 36:46)

## Technical details

- Agent Architecture & Workflow: Agents are built using a system that translates natural language into an intermediate representation (e.g., JSON/YAML), which is then compiled into a LangGraph-like workflow engine. This allows for self-healing and complex looping. (40:12)
- Context Management: Advanced context engineering involves quickly onboarding agents into massive, unfamiliar codebases and scoping work based on designated issues. Compaction techniques are necessary to manage the vast amount of data (e.g., thousands of meeting transcripts). (06:19, 16:13)
- Verification and Testing: Verification is critical for production agents. Methods include using browser-based recording/flow testing (like 'Loom' or 'movie' generation) or checking agent outputs against end-to-end or smoke tests. (06:19)
- MCP (Microservice/Agent Platform) Tools: The focus for MCP tools should be on designing around the *semantic intent* of the task rather than a simple one-to-one API call. This allows the agent to use multiple methods (e.g., keyword vs. semantic search) to fulfill a single goal. (38:44)

## Practical implications

- Build engineers should prioritize designing agent workflows that are robust enough to handle failure and require explicit verification steps, rather than assuming perfect execution.
- Focus on building abstraction layers (the 'harness') that interpret user intent, rather than merely wrapping existing APIs.
- Treat proprietary data traces and interaction logs as core, high-value assets for both observability and model fine-tuning.
- The development team must empower domain experts to articulate their intent, and software engineers to codify those workflows, bridging the 'translation' gap.

## Topics

AI Agents, Software Development Lifecycle (SDLC), Agentic Workflows, Context Engineering, Build Systems, Microservices Architecture (MCP), Data Tracing, Claude Code, LangGraph, MCP (Microservice/Agent Platform), Jesse's Project

Source: https://www.youtube.com/watch?v=0_JtfuXVI10