# How Agents Changed Vibe Coding Forever

Beyang Liu, Sourcegraph | MLOps Community | 49:49
Hosted by Demetrios Brinkmann

Source: https://www.youtube.com/watch?v=ekHpNKtb9oY
Channel: MLOps Community, now AAIF Live (https://www.youtube.com/@AAIFLive-x1r). Summarised by MLOps Talks.
Page: https://mlopstalks.com/talks/how-agents-changed-vibe-coding-forever
Published: 2025-08-22
Tags: agents, coding-agents, context-engineering, cost, tool-use

## TL;DR
- Coding agents change software development by letting models search for context, use tools, run feedback loops, and complete much more of a task without constant human direction.
- The best way to use an agent is to provide high-level intent, useful context, and a validation path, then let it decide which files, tools, and steps are needed.
- Agent costs can be much higher than chat-based coding tools, but Beyang Liu argues that the relevant comparison is the human time saved, not the token bill alone.

## Summary
Beyang Liu describes a shift from autocomplete and chat-based coding assistants to agents that can reason, use tools, find context, and validate their own work. Sourcegraph built AMP around this model after seeing that older IDE interfaces encouraged users to micromanage the model. Liu argues that developers should give agents clear intent, context hints, feedback loops, and plans, then let them work with less intervention. Coding is especially suited to agents because compilers and tests provide strong feedback for training and execution. He also explains how AMP uses multiple models, sub agents, built-in tools, third-party connections, and MCP servers. The conversation extends beyond coding. Liu expects software input to move from clicking toward typing and voice, while visual output remains useful. He is direct that agent usage can cost hundreds or thousands of dollars per user per month for heavy users, but says the comparison should be with developer time and delivery speed.

## Key ideas
### Coding agents raise the amount of code a model can generate
[00:00](https://www.youtube.com/watch?v=ekHpNKtb9oY&t=0s)
Beyang Liu says the early coding-assistant model focused on autocomplete, where a developer typed a few characters and received a line completion. Sourcegraph then explored retrieval-augmented generation, combining code search with a chat model to answer technical questions and generate code. The larger change came with tool-use and reasoning models. In the chat-based era, Liu saw models generate roughly 30 to 50 percent of the code. AMP users are now generating 80, 90, or even 95 percent of their code, according to his description. The difference is that an agent can take actions, search for information, and work through a task instead of returning one isolated response.

### Agent interfaces remove manual context management
[04:18](https://www.youtube.com/watch?v=ekHpNKtb9oY&t=258s)
Liu argues that many chat-era coding products made developers manage the context window themselves. Users had to handle rules files, tags, toggles, and manually selected snippets so the model could produce a single answer. Agents can search for context and use tools on their own, so the developer can describe the intended outcome at a higher level. He compares this with the shift from Yahoo's directory of links to Google search. The old skill was knowing what to click and which context to assemble. The new skill is giving an agent enough direction to work effectively without intervening at every step.

### Micromanaging an agent prevents it from acting like an engineer
[07:17](https://www.youtube.com/watch?v=ekHpNKtb9oY&t=437s)
The interface trains users how to behave. Liu says people who have learned the Cursor-style workflow often want to review every change before applying it because that was useful when models could not reliably correct their own mistakes. With agents, he recommends giving enough context for the system to decide what to search, which commands to run, and how to validate the result. He compares the older workflow with supervising a coding student line by line. A modern agent is closer to a junior, mid-level, or sometimes senior engineer. The developer should provide the overall context and the shape of the feedback loop, then allow the agent to work.

### Power users combine detailed instructions with parallel work
[09:32](https://www.youtube.com/watch?v=ekHpNKtb9oY&t=572s)
AMP's most advanced users consume far more tokens than the median user, and Liu says their behavior helps Sourcegraph discover new product directions. They give the agent information up front so it can find the right context and construct useful feedback loops. They also split work across interfaces. The VS Code extension is useful for complex tasks where the developer wants to remain involved. The command-line interface can run several shallower tasks in parallel, with users keeping multiple AMP CLI instances open in a T-Mux window for separate bugs or issues. Sourcegraph talks with these users through social channels, Discord, and phone calls, and has hired some of them onto the AMP team.

### Feedback loops make coding a strong agent domain
[14:32](https://www.youtube.com/watch?v=ekHpNKtb9oY&t=872s)
AMP can look for a way to check whether its changes work. For front-end code, Liu gives the example of using Playwright to take a screenshot after changing a page, then comparing the result with the intended effect. For back-end code, the agent might run a unit test suite or another command-line check. This resembles the loop a human developer uses when reading output, printing values, and rerunning a test. Liu says agents sometimes need guidance, but they are generally good at finding these validation paths. Coding has an advantage over many other tasks because compilers and test runners provide clear signals about whether an action succeeded.

### Coding tests provide training feedback that other domains lack
[16:22](https://www.youtube.com/watch?v=ekHpNKtb9oY&t=982s)
Liu connects coding agents to model training. A compiler error or failed unit test gives an agent a concrete signal about whether an action was good or bad. That makes it possible to create simulated environments where a model tries an action, receives feedback, and tries again. He compares this with games such as chess, where a system can run many simulated games and receive a winning or losing signal. Liu says public data sources have largely been used already, while coding offers a way to generate targeted validation and training data. Sourcegraph does not train foundation models, but he says it uses this kind of validation for specific use cases.

### Prompting an agent works best through context, validation, and structure
[25:33](https://www.youtube.com/watch?v=ekHpNKtb9oY&t=1533s)
Liu groups useful prompting practices into three areas. Context hints tell the agent where to look in a large codebase or which tool can retrieve relevant information. Feedback-loop instructions point it toward a command or tool that can validate the approach. Structured instructions ask the agent to write a plan before starting a large task, which gives a human a chance to review the proposed steps. He also describes sub agents, which can handle a subtask such as searching a codebase or implementing one part of a feature. When the sub agent finishes, its working context does not consume the main agent's context window, allowing more complex tasks to fit within the available budget.

### AMP prioritizes time saved over keeping every task cheap
[31:17](https://www.youtube.com/watch?v=ekHpNKtb9oY&t=1877s)
Liu says Sourcegraph's primary objective is saving human time. Agentic coding tools can cost much more than chat-based tools. Average spending may grow from roughly 10 to 20 dollars per user per month to hundreds of dollars, while the heaviest users can reach thousands of dollars per month. He argues that this cost should be compared with the developer time saved. Keeping the agent artificially cheap can be a poor trade if it prevents the system from doing more useful work. He expects companies to judge these tools through developer productivity and feature delivery rather than comparing their raw model bills with older chat assistants.

### Software input may shift from clicking toward language
[35:23](https://www.youtube.com/watch?v=ekHpNKtb9oY&t=2123s)
Liu expects graphical interfaces to remain useful for showing results, but he thinks the main way people express intent will move toward typing and speaking. He describes clicking as a low-bit-rate input method because users must move through buttons and menus one action at a time. Language can communicate a much richer intent, and current models can translate that language into actions. The graphical user interface may therefore become an intermediate stage between command lines and agents. A user could describe a desired change to an application, while the system still returns visual output when images, listings, or other visual information are easier to inspect than text.

## Notable quotes
- Beyang Liu: "Our primary objective is to save human time." (00:00)
- Beyang Liu: "With agents, agents have the ability to use tools themselves, fetch contexts themselves." (05:26)
- Beyang Liu: "What you don't want to do is you don't want to babysit them." (08:53)
- Beyang Liu: "The number one anti-pattern is people trying to use coding agents in just the same way that they use the chat-based coding assistants." (22:41)
- Beyang Liu: "The graphical user interface was a blip in between command lines and agents." (36:23)

## Tools & references mentioned
- Sourcegraph
- AMP
- Cody
- Yahoo
- Google
- VS Code
- Cursor
- Playwright
- Claude 3.7 Sonnet
- Claude 4
- Claude 3 Opus
- Gemini
- Oracle
- MCP
- Linear
- GitHub
- Sentry
- Canva
- Jeff Huntley

## Who should watch
- You are building or choosing an AI coding tool and need to understand why an agent needs a different interface from a chat assistant.
- Your team spends too much time selecting context, approving small edits, or correcting model mistakes, and you want concrete ways to change that workflow.
- You are evaluating agent costs and need a framework that compares model spending with the developer time saved.

## Related talks

- [AI Coding Agents Change Software Development Forever](https://mlopstalks.com/talks/ai-coding-agents-change-software-development-forever) (Michele Catasta, Replit & Aparna Dhinakaran, Arize AI & Erik Schluntz, Anthropic, 20:32)
- [The Future of Coding: AI Agents & the Next Tech Revolution](https://mlopstalks.com/talks/the-future-of-coding-ai-agents-the-next-tech-revolution) (Ricky Doar, Cursor, 26:45)
- [Co-Engineering: The New Era of Human-AI Collaboration](https://mlopstalks.com/talks/co-engineering-the-new-era-of-human-ai-collaboration) (Kiriti Badam, OpenAI, 29:25)
- [Coding with AI](https://mlopstalks.com/talks/coding-with-ai) (Chip Huyen, Tep Studio, 44:29)
- [Coding Agents Are Secretly General Agents](https://mlopstalks.com/talks/coding-agents-are-secretly-general-agents) (Jay Hack, ClickUp, 1:12:03)