Key Takeaways

  • Mihail Eric teaches Stanford students in CS146S to build functioning coding agents using an introductory 200-line Python loop.
  • Eric used mitmproxy to intercept live payloads from Anthropic's Claude Code running on Opus 55 just two days after the model was released.
  • Production coding runtimes rely on three distinct operational prompts: a system prompt, an explicit planning prompt, and a compaction prompt to manage context.
  • Instructions detailing git syntax and workflow setup have vanished from system prompts because modern foundation models absorb tool operations directly into their weights.
  • Leading developer agents avoid dozens of narrow API tools in favor of flexible, general-purpose utilities like Bash and SQL.

What You See When You Intercept Claude Code

In his Stanford course CS146S, “The Modern Software Developer,” (play from 0:11) Mihail Eric strips the mystery away from AI agents on day one. Junior developers often assume an autonomous coder requires a massive, proprietary software framework. Eric shows that the core mechanism is basic: “You could sort of through pretty much introductory algorithms level understanding you could just define essentially an agentic loop that does the bulk of what you would call a coding agent.” (play from 26:04) That foundational loop takes around 200 lines of Python. At its base, the script sends context to an LLM, reads a requested tool call, runs the command, and passes the output back into the message array.

The divide between a simple classroom script and a commercial tool like Claude Code comes down to prompt orchestration and context management.

To show students how production systems operate, Eric installed mitmproxy to capture every raw HTTP packet traveling between Anthropic's client and their backend. He tested the setup against Opus 55 when the model was barely 48 hours old: “I intercepted those requests. Here is exactly what is going on: here is the prompt, here is the system prompt, here is the plan prompt, here is the compaction prompt, and then we just went through all of that.” (play from 28:10)

The network logs showed that Anthropic does not rely on one giant prompt to handle everything. The runtime switches between discrete states. It initializes boundaries with a system prompt, runs an explicit planning prompt to map multi-step edits, and calls a compaction prompt to condense conversation history before the context window fills up.

Foundation Model Weights Are Eating System Prompts

Building agent infrastructure used to mean writing endless operational guardrails. Early developer loops packed detailed documentation into the system prompt: exact syntax for git branches, formatting constraints for task trackers, and step-by-step logic for running shell commands.

That extra text is disappearing. As Eric explained: “Turns out that now what was once part of the system prompt, things like how to use even git, or how to set up tasks or things of that nature, are no longer part of the system prompt. It is actually expected to be more captured in the model weights itself.” (play from 31:06)

Modern frontier models arrive with fluent knowledge of standard developer tools. They know how to format commits, parse compiler errors, and handle shell pipelines without hand-holding. Teams that continue cramming basic tool instructions into their system prompts waste tokens and dilute model attention.

Production architectures are also abandoning hyper-specific tool endpoints. Instead of maintaining separate integrations for file viewing, searching, and moving, builders rely on broad shell execution. As Eric noted: “In the early days they are among the first to really lean into this let fewer tools do more. Lean into SQL, lean into Bash, lean into the things that are powerful Swiss Army knife tools and have that be a lot of the driver of capability.” (play from 30:39)

What to Do With This

Set up mitmproxy on your machine, point your local environment at it, and run your primary coding agent against a test repository. Inspect the intercepted JSON payloads to see how production tools handle planning and context compaction. Then, review your own agent prompts and delete any instructions explaining standard developer tools like git, bash, or file navigation.