What is the difference between the smart agent and the fast agent in AMP?

The smart agent aims for higher capability and quality, typically with pricing based on usage. The fast agent is a cheaper, ad-supported option that trades some capabilities for speed and lower cost. This creates a pricing frontier where users can choose between deeper intelligence and lower latency depending on their needs.

Why are open-source models becoming more important for AMP?

Open-source models allow post-training customization for specific tasks (e.g., context retrieval, reasoning libraries) and offer pricing advantages. AMP uses a mix of open-weight and closed models, selecting smaller, faster models for certain sub-tasks while reserving larger models for higher-quality capabilities.

Do they train their own models or rely on pre-trained ones?

AMP teams train their own models but do not train from scratch; they leverage pre-trained foundations and then perform post-training for domain-specific tasks. They emphasize cost-effectiveness and practicality, noting that full-from-scratch training would be fiscally irresponsible at current scales.

Will software development in 10 years rely more on agents than traditional IDEs?

The guest predicts that IDEs as we know them will be replaced by more agent-enabled environments, where humans orchestrate multiple agents. The human remains essential for high-level decisions and creative problem solving, but most actionable coding will occur through agent-assisted workflows with humans guiding the overall plan.

What are evals in AI agent development, and should they be optimized as product metrics?

Evals are useful as unit tests or smoke tests to detect when crucial workflows break. However, optimizing for a single eval metric can mislead product outcomes, since real user experience is broader and more nuanced. The discussion warns against over-optimizing for a proxy metric like completion acceptance rate.

What policy changes could help sustain a competitive US AI ecosystem and open-source efforts?

The speakers advocate for a clear, nationwide regulatory standard focused on specific applications rather than existential risk, plus maintaining healthy competition at the model layer. They caution against regulatory lock-in and emphasize openness to keep the ecosystem dynamic and globally competitive.

The Truth About Coding Agents: Why 90% of Your Time Is Now Code Review

a16z

Gaming5 min read47 min video

Nov 25, 2025|2,771 views|38|8

Save to Pod

Key Moments

TL;DR

AI agents shift coding from typing to orchestration, via AMP and improved code-review UX.

Key Insights

Agent-centric design: the core unit is the agent (model + tools + prompts), not any single model.

AMP evolves coding workflows: from code search/navigation to an orchestration layer that helps both professionals and hobbyists.

Trade-offs along the frontier: speed (latency) versus intelligence (model power) drive pricing and product choices (ads vs usage-based).

Open source vs closed models: post-training and domain-specific tuning on open weights become increasingly important for latency and cost.

Policy and ecosystem dynamics matter: global model availability, security hosting, and regulatory clarity shape competitiveness and innovation.

UI/UX for review matters: better in-editor code-review experiences are critical to maintain productivity as coding becomes agent-driven.

FROM CODE SEARCH TO CODING AGENTS: AMP AND THE AGENT-CENTRIC SHIFT

The discussion begins by challenging the notion that coding can remain purely about correctness and static logic, especially as AI accelerates how we build software. The guest, Guido, co-founder of Sourcegraph, traces the company’s arc from delivering a production-quality code search engine to tackling the broader problem of understanding and navigating massive codebases in large organizations. As language models matured, the team explored how to blend AI with their existing strengths, initially leveraging LM-based enhancements to ranking signals in code search. The pivotal turn came with AMP, a dedicated coding agent designed to operate inside large codebases and also to be approachable for enthusiasts like Guido’s father who used it to build a simple arithmetic game for his kid. AMP represents a deliberate architectural pivot: they built AMP almost as a separate product from their core search/navigation stack because the agent’s requirements—robust tool use, interactive problem-solving, and real-time collaboration—demanded a fresh design approach. The result is a dual-path strategy: a fast, latency-conscious agent suitable for targeted edits and a smarter, takeaway-driven agent for more complex tasks. This evolution encapsulates a broader industry shift from purely human-driven coding to tools that orchestrate multiple AI capabilities in service of human intent.

THE AGENT CONTRACT: MODEL, TOOLS, AND BEHAVIOR

A central theme is that the agent—not the model alone—defines how code gets produced. Guido explains that an agent is a contract: the user inputs text and receives outcomes that depend on a combination of the model, system prompts, tool availability, tool descriptions, and feedback loops. Swapping one model for another can yield very different behaviors if the surrounding tool ecosystem changes, even with the same prompt. This refactoring reframes AI as an ‘agent-centric’ problem: the system is defined by how tools are described and invoked, how the agent reasons, and how it interacts with feedback, rather than by chasing the frontier model alone. The conversation touches on evals as a unit test approach for stability, warning against over-optimizing to a specific eval metric, as this can misalign with real user experience. The team’s exploration into code-review enhancements—like a dedicated code-review panel in their editor—illustrates a practical shift from traditional code-host reviews to tool-assisted, task-oriented review that aligns with the agentic workflow.

OPEN SOURCE MODELS, POST-TRAINING, AND GLOBAL SUPPLY DYNAMICS

A major portion of the discussion centers on the model landscape and policy implications. Guido notes that AMP uses a mix of closed and open models, with a strong emphasis on post-training for domain-specific subagents (e.g., context retrieval or specialized reasoning) to optimize specific tasks. Open-weight models enable post-training, allowing teams to fine-tune for particular workflows without rebuilding from scratch, which is crucial for latency and cost. The conversation highlights a shift toward using smaller or specialized models for fast, interactive tasks, while keeping larger, more capable models for overarching reasoning. A global dimension emerges when discussing model origins: the most effective open-weight models for agentic tool use are currently of Chinese origin, raising concerns about dependency and strategic competition. Guido argues that the US ecosystem should foster competitive open-source offerings to avoid over-reliance on non-Western sources, while noting security considerations (models hosted on American servers) as a baseline requirement. The broader takeaway is that a diverse, well-supported open-source open-weight ecosystem is essential for sustained innovation and national competitiveness.

MONETIZATION, LATENCY, AND THE FRONTIER OF AI CODING

Pricing and performance trade-offs are a recurring theme. AMP offers two top-tier agents: a smart agent that remains on a usage-based pricing frontier and a fast, ad-supported agent designed for quick, targeted edits. This dichotomy reflects a broader industry pattern: the most capable models tend to be slower, while faster models sacrifice some depth of reasoning but dramatically improve interactivity. The team’s experimentation with a fast, lightweight agent—supported by ads—demonstrates how product economics can expand access without sacrificing core capabilities. The dialogue also touches on the practical realities of tool use: engineers often value a balance between speed and accuracy, and different tasks call for different agent configurations. The evolving market frontier—where speed, cost, and intelligence intersect—remains a key determinant of which models and which agent architectures gain traction in real-world workflows, including education, hobby coding, and enterprise software development.

THE FUTURE OF SOFTWARE ENGINEERING: UI, POLICY, AND EDUCATION

Looking ahead, the conversation shifts to a view of software engineering where humans orchestrate multiple agents to accomplish complex tasks. The speakers predict that the next decade will not resemble today’s IDE or terminal-based workflows; instead, humans will manage multi-agent orchestration, monitor essential outputs for comprehension, and intervene only when necessary. This shift promises to dramatically increase productivity—indeed, Guido suggests that a large portion of code may come from agent-assisted workflows—while also raising questions about the human bottleneck: understanding and validating what agents produce. The discussion returns to the code-review experience, acknowledging that current interfaces are suboptimal and that improved in-editor review tools can greatly enhance developer experience. On policy, the speakers call for reasonable, standardized regulations that foster competition and innovation rather than stifling it, and they emphasize the risk of over-reliance on any single model or ecosystem. They also stress the importance of maintaining a healthy US open-source and regulatory environment to sustain leadership in AI-enabled software engineering and to avoid a future where critical tooling becomes strategically centralized abroad. The episode leaves readers with a pragmatic optimism: AI will augment creativity and efficiency, but human judgment, governance, and education will remain central to responsible progress.

Mentioned in This Episode

●Software & Apps

●Tools

●Concepts

●People Referenced

Common Questions

AMP is a coding agent designed to help developers work more efficiently in large codebases by coordinating tool use and reasoning. Sourcegraph built AMP to extend their existing code-search tooling with an agent that can perform complex, multi-step tasks. The discussion highlights how AMP started as a separate project from their core codebase to explore first-principles agent design.