How Agents Changed Vibe Coding Forever
Sourcegraph CTO Beyang Liu discusses the evolution from chat-based coding assistants to autonomous AI agents like AMP. He explains how new models with tool-use and reasoning capabilities are creating a paradigm shift, moving developers from micromanaging AI to instructing it at a high level, dramatically increasing productivity by automating complex coding tasks.
The Evolution from Chat-Based Assistants to Autonomous Agents
The paradigm for using Large Language Models (LLMs) in software development has undergone a significant transformation, moving from the “chat LLM era” to the “agentic model era.” Initially, the dominant modality was autocomplete-style assistance, like GitHub Copilot, which evolved into chat-based assistants that utilized Retrieval-Augmented Generation (RAG). Sourcegraph’s first AI tool, Cody, was a prime example of this era, excelling by combining code search with a chat LLM to provide context-aware code generation and technical answers.
However, this approach required significant manual effort from the developer. The user was responsible for managing the context window, manually specifying files, and using various UI toggles to guide the LLM. This process could be effective but often felt like “micromanaging” the AI, which was necessary because these models lacked the ability to self-correct or iterate based on feedback.
The advent of models with advanced tool-use and reasoning capabilities has unlocked a new application paradigm: coding agents. These agents represent a leap from generating 30-50% of code in the chat era to automating 80-95% of a developer’s task. This shift is analogous to the transition from the Yahoo web directory, which required manual navigation through links, to Google Search, which allows users to simply state their intent.
A New Paradigm: Instructing, Not Micromanaging
The ideal user experience (UX) for coding agents is fundamentally different from and often in “direct tension with” the UX of older chat-based tools. The old GUI-heavy interfaces encouraged a hands-on, step-by-step approach. With agents, this becomes an anti-pattern.
The new interaction model is about delegation and high-level instruction. Instead of reviewing every small change, the developer’s role shifts to providing the agent with the overall goal, the necessary context, and the correct feedback loop. It’s the difference between tutoring a coding student on every line and briefing a professional junior engineer on a task and letting them run with it. The agent can now use tools to fetch its own context, run tests to validate its work, and iterate on its own mistakes.
This requires a new skill set for developers, centered on effectively “programming the agent through natural language.” Users who try to apply the old micromanagement habits often get frustrated and fail to unlock the agent’s full potential. A subtle but important UX choice in Sourcegraph’s agent, AMP, is that hitting Enter creates a new line, while Command+Enter submits the prompt. This encourages users to write longer, more detailed instructions, providing the rich context agents thrive on.
The Critical Role of Feedback Loops
Coding is a uniquely powerful domain for AI agents because it has strong, objective validators. An agent can construct its own feedback loops to verify its work:
- Back-end Code: It can run unit tests or other command-line invocations to check if its changes are correct and pass the test suite.
- Front-end Code: It can use tools like Playwright to take screenshots of the UI, visually confirming that a change (e.g., “make this background red”) had the intended effect.
This ability to create a “read-eval-print loop” allows the agent to iterate and self-correct with high fidelity. This strong validation mechanism is also key to model improvement, as it creates a reliable environment for reinforcement learning. By treating compiler errors and test failures as feedback in a simulated environment, it’s possible to generate high-quality synthetic data to train more capable models.
Mastering Agent Interaction: Prompting and Architecture
Effectively using a coding agent involves providing the right inputs. Beyang Liu outlines three key categories of “prompting tricks”:
- Context Hints: Guiding the agent on where to look within a large codebase (e.g., specific directories or files) to reduce the search space and conserve tokens.
- Feedback Loops: Explicitly telling the agent which command to use for validation (e.g., “use this command to run the tests”).
- Structured Approaches & Planning: Instructing the agent to first create a step-by-step plan for a complex task, allowing for human review before execution.
To handle more complex tasks without exhausting the context window, AMP utilizes sub-agents. The main agent can delegate a sub-task, like searching the codebase or implementing a specific feature, to a sub-agent. Once the sub-agent completes its task, the tokens it used are “garbage collected,” preserving the main agent’s context window for the overarching goal.
Furthermore, AMP employs a multi-model strategy. While one model drives the core agentic tool use, another model excelling at deep, nuanced thinking (like Claude 3 Opus) can be invoked as a tool called “Oracle” for particularly complex reasoning tasks.
The Economics and Future of AI in Development
While agentic tools consume significantly more tokens—pushing monthly costs from tens to hundreds or even thousands of dollars for power users—the primary objective is to save human time. Developer time is an organization’s most valuable and expensive resource. The productivity gains and increased feature velocity unlocked by agents offer a return on investment that makes the cost a “no-brainer.”
Looking ahead, the trend points towards natural language becoming the primary input modality for software. The Graphical User Interface (GUI) can be seen as a “blip in between command lines and agents.” While visual outputs will remain important, the low-bitrate, point-and-click method of articulating intent is being replaced by the high-bitrate communication of language, fundamentally changing how we interact with all applications, not just development tools.