Latent Space: The AI Engineer Podcast

Episode: Amp: The Emperor Has No Clothes

Date: September 25, 2025
Participants:

• Alessio (“A”), Founder of Kernel Labs (Host)
• Quinn (“B”), CEO of Sourcegraph
• Thorsten (“C”), Lead Engineer & Creator of AMP, Sourcegraph

Episode Overview

This episode explores the journey from Sourcegraph’s earlier product, Cody, to its next-generation coding agent: amp. Alessio, Quinn, and Thorsten dive into the technical, organizational, and philosophical underpinnings of building at the forefront of the rapidly shifting AI agent landscape. They dissect the nature of product iteration in an “everything changes” world, the evolution of developer tooling, the realities of agentic coding, and their bets for the future of developers and enterprises.

Key Discussion Points & Insights

1. From Cody to AMP: Why a New Start

[00:50-05:15]

• AMP spun out of an experimental hack with Anthropic’s Claude models. Thorsten describes the moment of realizing the new agent needed a complete reset of expectations—technically, contractually, and brand-wise.
• Cody satisfied a different era’s needs, deeply tied into the Sourcegraph platform and its release cycles, while AMP needed "room to move 15x faster—ship 15 times a day" (C, 04:24).
• The business logic: AMP was differentiated enough to justify shedding old contracts and user expectations, to avoid being disrupted by competitors and by the pace of model change.

“The only thing that matters is building the best coding agent. Nothing else matters.”
— Quinn (B), [03:14]

2. Surviving and Thriving Amid Relentless Change

[05:15-07:55]

• The team’s “number one priority” is being positioned to react quickly and capitalize on every shift in the landscape, as no leader is safe for long (example: Cursor’s rapid rise and leveling off).
• AMP’s engineering approach: minimal bureaucracy, dogfooding, hyper-fast iteration, direct customer feedback.

“We’re growing more than 50% month over month...but it’s more about how do we get to be the first ones with that 10 to 100x improvement?”
— Quinn (B), [05:20]

3. How Internal Velocity Shapes Product & Team

[07:55-12:23]

• The core AMP team is small (roughly 8 people), with no formal code reviews, pushing directly to main, balancing Google-scale code discipline with “duct tape mode.”
• This “reset” approach creates freedom from legacy thinking and processes; the best results come from dogfooding and rapid internal feedback.
• Platform teams provide stability (infra, security, etc.), letting AMP focus on the application and UX layers, which can “tear down and rebuild as fast as possible” (C, 12:06).

4. Product Structure: CLI vs Editor Extensions

[12:23-19:59]

• Started with a VS Code extension for speed and easy distribution, then built a CLI for flexibility.
• Surprised by the adoption of CLI interfaces—even among those initially skeptical—because of their “free” power, portability, and native capabilities.
• Internal data show a near 50/50 split between VS Code and CLI users ([16:48]).
• The team stays ready to cut surface area, evaluating whether to keep both clients, but ongoing shifts (like async agents requiring new modes of interaction) justify the complexity, for now.

“There’s always a hand hovering over the button—can we reduce complexity? So we’re again in the spot where, if a new model comes out, we can react quickly.”
— Thorsten (C), [18:49]

5. Strategic Product Philosophy & Chosen User

[19:59-23:18]

• AMP does not try to maximize for today’s largest revenue/user base because everything is changing too fast; instead, it targets frontier engineers.
• Features requested by some users (model choice, BYO key, pricing games) tend to slow product velocity and are intentionally deprioritized.

“We alone among the entire industry, it feels like we are being really honest and really bold with that.”
— Quinn (B), [21:56]

6. Is Model Choice Still Important?

[23:18-27:06]

• The “best model” moment—where each editor touted supporting the latest model—has faded; now, the system prompt, harness, and surrounding software matter more than which LLM sits at the core.
• Sourcegraph’s philosophy: Make the model an implementation detail and tune the scaffolding around it instead of exposing model selection to users.

“I think we’re going towards a future where the model will become an implementation detail to some sense and we will end up on a different abstraction layer.”
— Thorsten (C), [25:31]

7. Navigating the Model Provider Meta-Game

[27:06-30:39]

• Rapid evolution of models (Sonnet, GPT-5, Qwen, open source, etc.) requires constant re-evaluation.
• AMP users internally are already shifting to new models, reflecting this ongoing change.
• Being multi-model enables AMP to combine strengths across providers and switch fast, including prepping for open-source options.

“We are one or two months away from a possible news cycle that is the foundation model companies…now you know, they’re no longer the best in this realm and there’s a huge stampede away from them. That’s very possible.”
— Quinn (B), [30:13]

8. Tooling, Customization, and the Bitter Lesson

[31:59-42:00]

• The team deliberately limits scaffolding and feature creep, betting that future models will eat many current features.
• Non-determinism and rapid model evolution make elaborate deterministic workflows risky and often temporary.
• They caution against overengineering workflows (“prompt enhancer is a bullshit feature”), and emphasize that most users won’t even set up the context sources/cloud integrations that seem obvious to product builders.

“Compact is such an alluring thing where people think, ‘oh, I ran out of context, I hit that button, now I’m back to the start.’ But you lose signal, you lose data… is it good enough to really glance over this, that the user doesn’t have to worry about it?”
— Thorsten (C), [42:00]

9. Building for the Frontier, Not the Mainstream

[38:28-39:50]

• Focus on users “at the frontier” or open to learning this new paradigm. Building for mainstream (“those who do not know what a good prompt looks like”) risks falling behind.

10. Context, Failure Modes, and Agent Limitations

[43:34-48:23]

• The podcast discusses context engineering, challenges of compacting conversation, and failure modes (e.g., “outsourcing the thinking but not the typing”).
• Users need to adapt their workflows: starting new threads, carefully curating context, adding instrumentation for agents.
• Model/tool mismatch is common; “you can sense different philosophies in the model houses,” regarding memory, tool usage, etc.

“For me, the meta thing here too is everything is changing. That means CLI tools right now are also adopting to being used by agents, so they’re changing the output too.”
— Thorsten (C), [44:55]

11. Developer Workflow: Testing, Logging, and Feedback Loops

[48:23-54:11]

• The team expects core hooks (test runtimes, infra as code/apparatus) will always remain explicit for agents, but that many custom tools will get subsumed by models.
• More logs, more visible context, and instrumentation for machine (not human) consumers will emerge. Unified logs, structured machine-readable output, etc., are new best practices.

“That’s just a little preview... this is not made for human consumption anymore. How can we optimize this for agentic consumption? And then maybe the game changes.”
— Thorsten (C), [53:04]

12. Adoption, Laggards, and Market Forces

[57:08-60:47]

• AMP targets users eager to adapt workflows and even change codebases to maximize value from agents (in contrast with the more common developer tooling adoption, which adapts tools to existing codebases).
• Most companies/teams remain skeptical; AMP focuses on early adopters and letting laggards catch up—or not.

“If you waste your time trying to make [laggards] realize it, you’re going to be trounced by … people like us that are only focused on the early adopters. It’s a total mindset shift.”
— Quinn (B), [60:47]

13. Outer Loop and Async Agents: What’s Still Missing?

[61:46-65:40]

• Next challenge: the “outer loop”—making it clear and easy to orient to agent work across multiple async agents and tasks.
• The importance of new UIs and better mechanisms for cross-agent orchestration, summarization, and diff understanding.

“If you’re playing chess... people in Central Park who play against 10 different tables at once... they get oriented, make a move, and go. That’s what we’re trying to build.”
— Quinn (B), [63:45]

14. On Code, Product, and Team Evolution

[72:22-78:54]

• AMP’s team structure encourages cross-disciplinary engineers with product sense and business insight—not just code typers.
• No formal evals; instead, rapid user/team feedback and vibe-based iteration.
• The value of engineering is increasingly in judgment, integration, and taste, not just code composition.

“You now need to know a lot more about the other parts... Otherwise, I think the value of your work will diminish over time because the pure typing out of code... will diminish.”
— Thorsten (C), [75:33]

15. Final Reflections & Calls to Action

[79:14-end]

• The AMP team is hiring and welcomes engineers and agent programmers “fully in this,” acknowledging programming itself is changing fast.
• They’re looking for ongoing feedback, collaboration, and shared learnings from the front lines.
• Concluding vibe: building the “final boss” of coding agents is fun, daunting, and more open than ever.

“We feel like kids in a candy shop. Just that we get to go build the future of coding. Feels like the final boss.”
— Quinn (B), [79:43]

Notable Quotes

| Timestamp | Speaker | Quote | |-----------|---------|-------| | 03:14 | B (Quinn) | “The only thing that matters is building the best coding agent. Nothing else matters.” | | 04:24 | C (Thorsten) | “With AMP, we basically said, let’s undo this. Let’s build something that allows us to ship 15 times a day.” | | 18:49 | C (Thorsten) | “There’s always a hand hovering over the button to can we get rid of this? Can we shed weight?...if a new model comes out, we can react quickly.” | | 21:56 | B (Quinn) | “We alone among the entire industry, it feels like we are being really honest and really bold with that.” | | 25:31 | C (Thorsten) | “I think we’re going towards a future where the model will become an implementation detail to some sense and we will end up on a different abstraction layer.” | | 30:13 | B (Quinn) | “We are one or two months away from a possible news cycle that is the foundation model companies...now you know, they’re no longer the best in this realm and there’s a huge stampede away from them. That’s very possible.” | | 39:50 | B (Quinn) | “Prompt enhancer, that’s a bullshit feature that doesn’t actually work.” | | 42:00 | C (Thorsten) | “Compact is such a alluring thing...but you lose signal, you lose data...is compacting good enough...?” | | 53:04 | C (Thorsten) | “That’s just a little preview...this is not made for human consumption anymore. How can we optimize this for agentic consumption? And then maybe the game changes.” | | 60:47 | B (Quinn) | “If you waste your time trying to make [laggards] realize it, you’re going to be trounced by ... people like us that are only focused on the early adopters. It’s a total mindset shift.” | | 75:33 | C (Thorsten) | “As an engineer or any of the three, you now need to know a lot more about the other parts...Otherwise I think the value of your work will diminish over time because the pure typing out of code...will diminish.” | | 79:43 | B (Quinn) | “We feel like kids in a candy shop. Just that we get to go build the future of coding. Feels like the final boss.” |

Important Timestamps

• 00:50 – Backstory: Cody → AMP, brand/contract reset
• 03:14 – “The only thing that matters is building the best coding agent…”
• 05:20 – AMP’s explosive growth, but focus on “the 10-100x improvement”
• 12:23 – CLI vs. VS Code extension: rationale and user split
• 16:48 – Internal survey: CLI vs editor users, generational divide
• 21:56 – Standing out on “being honest and bold”
• 25:31 – Model abstraction and future direction
• 30:13 – Prediction: stampede away from incumbent model providers?
• 42:00 – Ripping out features; the compact-conversation dilemma
• 53:04 – Logs and agentic consumption
• 60:47 – Early adopters vs. laggards: why AMP doesn’t chase everyone
• 65:40 – Code review, multi-agent orchestration, “outer loop”
• 75:33 – Modern engineering, skills needed, diminishing value of “just code”
• 79:43 – The “candy shop” spirit; call to engineers

Summary: Episode Takeaways

• Velocity and flexibility are existential: The team frames everything (from product decisions to team structure) around reacting quickly to market and technology shifts.
• The best coding agent isn’t static: It’s a moving target, requiring continual disruption, rapid user feedback, and a willingness to throw out what worked six months ago.
• AMP bets on early adopters and the power user: Purposefully limiting features and “scaffolding,” focusing on those ready to exploit the bleeding edge.
• The model wars are ending; orchestration and UX matter more: System prompts, harnesses, test runtimes, and instrumented logs are the new competitive battlegrounds.
• You can’t outsource your engineering judgment (yet): Agentic tools require context, review, and careful workflow design; mass adoption is gated by real, not perceived, capability.
• AMP is hiring and listening: The team is looking for frontline AI engineers, open discourse, and feedback to shape the next evolution of code agents.

For more notes and future episodes, visit latent.space.