AI Engineer Code 2025
Amp Code: Next-Generation AI Coding
Loading slides…
Read the talk
Amp Code: Next-Generation AI Coding
A Help-button demo leads into Amp’s architecture: specialized tools and subagents conserve context, while distinct execution modes and review interfaces shape how developers work.
From a talk by Beyang Liu
Before you start: Familiarity with code diffs, editor diagnostics, and language-model tool calls will help you follow the architecture.
Adding a Help button to the agent itself
What should a coding agent show you while it changes its own interface? That small design problem opens Beyang Liu’s demonstration of Amp. He introduces the product as an opinionated frontier agent, represented by the team’s deliberately strange mascot: a Pied Piper figure riding a floating golden fish. The ambition is to explore how developers might work a year into the future, as agents write an increasing share of their code.
Amp’s terminal interface runs on a custom UI framework. It exposes selected activity rather than every token of the model’s explanation: diffs stream as files change, and command displays show which CLI operations the agent uses. An Emacs 30.1 indicator also shows an editor connection. Those connections—to Emacs, Neovim, or JetBrains—let the terminal agent collect diagnostics relevant to its task.
The task is to add a Help button in the bottom-left corner of Amp itself. The demonstration follows the agent finding relevant context and iterating on the change; its visible result includes a terminal help panel listing keyboard shortcuts. The useful unit of interaction is already larger than a completion: the agent investigates a codebase, changes it, and exposes enough activity for a person to follow.
The recording also shows an editor extension that installs into VS Code and derivatives including Cursor, Windsurf, and Antigravity, without maintaining a VS Code fork. This is the historical editor experience: Amp later announced retirement of its VS Code and Cursor extensions, scheduled for March 5, 2026.
Liu describes writing primarily through the agent panel and spending little time manually editing. That shifts the constraint from producing code to understanding it. Reviewing agent output is what keeps him from running substantially more agents concurrently. Amp’s response is a dedicated review interface that helps developers understand changes before shipping them. More generated code only helps if people can review it effectively.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The few levers inside an agent loop
The next question is what makes the architecture different. Liu leaves judgments of superiority to developers trying the tools themselves; his explanation instead follows the decisions made while building Amp. At its core, an agent is a loop containing a model and tool calls. That gives its builder three principal levers: model choice, tool descriptions, and how the model iterates with tools. A small set of controls can produce widely different behavior, just as conditionals and loops support complex ordinary programs.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Tune the tools, then protect the context window
The first architectural choice concerns tools. MCP made providing context to agents a much broader activity, but Amp still had to decide where to invest: many integrations or a carefully refined internal tool set. The team prioritized its core tools for two related reasons.
- Close the right feedback loops. A useful coding agent must find feedback that helps it make progress. Liu argues that Amp can tune its own tools and descriptions around those objectives, whereas an external MCP server author does not necessarily know what Amp is trying to accomplish.
- Reduce irrelevant choices. Every additional tool description gives the model another option to consider. When those options do not help the current task, they can create context confusion.
This is an argument for investing in task-specific tools, not a claim that MCP itself prevents specialization or that Amp has no MCP support.
Descriptions are only one source of context consumption. Tool calls and their results also accumulate. A diligent coding agent may grep the repository and read many files before editing, leaving too little room to complete the change. Telling it to read less appears to solve the capacity problem, but introduces another: without enough initial context, it may repeatedly attempt the same unsuccessful fix. Liu calls this the doom loop.
| Approach | What happens to context | Failure or benefit |
|---|---|---|
| Search in the main agent | Investigation fills the main window | Too little room remains for editing |
| Prompt the agent to read less | Less evidence is gathered | Repeated attempts can miss the cause |
| Delegate the investigation | A subagent holds the detailed search | Relevant results return to the main agent |
Subagents provide the escape from this tradeoff. Like a subroutine, a subagent handles a bounded piece of work; unlike an ordinary function, it also has a separate context window. It can perform the necessary investigation there and return only the relevant results. The main agent retains useful findings without carrying the entire search history into every subsequent step.
Amp takes that separation beyond generic subagents with slightly different prompts or tools. Its specialized agents are designed to extend particular capabilities of the main agent. The design question becomes which work deserves its own model, tools, and context—not simply how many copies of the same agent to launch.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Finder, Oracle, Librarian, and Kraken
Finder handles codebase search. After experimenting with different models, Amp settled on a relatively small, fast model driving a limited tool set for discovering relevant repository context. Its job is not to solve every part of the coding task; it is to find the material the rest of the task needs.
Oracle handles reasoning. Rather than making every interaction run through a slower reasoning model, Amp delegates difficult debugging or nuanced planning when needed. The main agent stays responsive and retains its broad tool use; Oracle takes over the harder analysis.
Liu describes explicitly tagging Oracle and asking it to think hard when the main agent gets stuck and he wants to avoid spending one or two hours investigating. He can switch away while it works. Liu estimates that Oracle finds the underlying issue about four out of five times in these difficult debugging situations, sometimes after a few minutes of thinking. That is his personal experience, rather than a measured success rate from a defined evaluation.
Librarian retrieves context beyond the local codebase, particularly from dependency libraries and frameworks. The experimental Kraken addresses a different scale of work: large refactors. Instead of editing files individually, it writes codemods that apply transformations across the codebase. These are distinct execution strategies, not merely different personalities attached to the same prompt.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Choose a working mode, not a model
Specialization also shapes Amp’s top-level interface. A model selector offers choice, but makes developers decide which model fits each task. It can also constrain the product architecture: if N models share one harness with only light customization, the harness may never fully exploit any individual model. Amp instead organizes the experience around agents with different operating characteristics.
| Mode | Intended work | Human involvement |
|---|---|---|
| Smart | More complex instructions; slower execution | Delegate, then review |
| Rush | Quick, targeted edits | Stay close and review each edit |
Liu highlights smart’s access to specialized subagents; that access was not exclusive, since the contemporary rush launch also documented access to all subagents. The central distinction is the interaction pattern. Smart suits work that can run asynchronously, while rush suits a developer actively steering a sequence of small changes. These are deliberately chosen points on the speed–intelligence frontier.
That approach makes the underlying model an integration decision. Liu describes the recent move to Gemini 3 Pro as smart’s first model switch, made two days before the talk. The announcement dates the change to November 18, 2025; his characterization concerns this transition, while Amp’s release history also records earlier Claude-version changes.
Liu expects the same model to behave differently across agent environments. Amp spent the week before release testing and optimizing smart for Gemini 3’s capabilities. He reports a positive early assessment while acknowledging remaining integration problems. The relevant object to evaluate is therefore the model together with its tools and harness—not the model name in isolation.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The editor becomes a readitor
The editor and terminal support different ways of working, so their interfaces need different strengths. Liu calls his editor a readitor: the agent panel drives changes, while the rest of the editor increasingly helps him read and understand them. Amp’s custom review interface puts file-level diffs in a dedicated panel.
The review workflow preserves the capabilities needed to investigate a change:
- Select an arbitrary commit range to define what you are reviewing.
- Move through the file-level diffs and edit them when necessary.
- Use go to definition and find references to understand the surrounding code.
- Follow a change tour that recommends which files to read first.
The last step addresses a specific source of review friction: in a large change, deciding where to begin can be half the work. The complete layout places that reading guide beside the diff and agent conversation.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Make activity readable, and make practice shareable
The terminal has its own design opportunities. Liu says a core contributor to Ghostty built Amp’s TUI framework from scratch to exploit modern terminal rendering. One detail is the green background used for additions in diffs: the interface can mix green with the terminal’s existing background color, making the highlighting fit its environment.
That richer rendering cannot be assumed everywhere. Users also run Amp in embedded JetBrains or VS Code terminals and in the default macOS Terminal. The TUI therefore degrades to the capabilities available in each environment. The goal is a readable agent interface across terminals, with richer presentation where the terminal supports it.
Readable output helps an individual developer follow an agent. Shared threads help a team learn how to direct one. Liu expects human developers to remain involved for a long time, but believes the craft of coding must be relearned together. Amp’s team experience lets people inspect how much code was changed with Amp over a period and open the threads behind particular work.
Those threads capture more than the final patch. A teammate can share a prompting technique that worked, or point to a stalled attempt and ask for help. The useful question is often how to connect the agent to a better feedback loop. Sharing the interaction makes that question inspectable instead of reducing it to a vague report that the agent succeeded or failed.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The experiment with sponsored inference
Learning also depends on being able to afford enough use. At the time of the talk, Liu describes smart inference as relatively expensive and rush inference as increasingly cheap, but not free. In conversations on college campuses, he found fewer students using coding agents than he expected and identified cost as a substantial barrier.
That led to an initially unlikely proposal: put advertisements in the terminal. As inference costs declined, the economics looked more plausible. Amp shipped a small ad network promoting developer tools in both the terminal and editor, with placements intended to be subtle and non-intrusive. Liu explains that the revenue sponsored rush inference so more people could use agents for work such as side projects. This was a historical experiment; Amp announced the removal of ads on March 30, 2026.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A community for experimenting with agents
Amp’s intended audience, Liu says, is not everyone: it is developers interested in exploring how agent-assisted work might evolve. He describes the company as an agent research lab and says it does not pay developer influencers. As examples of the audience it attracts, he names Mitchell Hashimoto, reportedly using Amp for many changes to Ghostty, and Hamel Husain, who Liu says had recently called Amp his favorite coding agent. Liu also says neither was on the team or an investor. These are attributed user endorsements, not comparative evaluations.
The closing invitation extends beyond the product. The community shown on the slide, Build Crew, welcomes people experimenting with agents whether or not they use Amp. It is run by Ryan Carson; Liu says Carson’s former startup, Treehouse, taught more than one million people to code. The new community focuses on learning alongside others who are pushing agents into unfamiliar work.
Its activities include regular interviews with people building interesting projects or using agents in unusual ways, plus in-person events. Liu describes the previous night’s dinner as moving between practical coding-agent work and philosophical questions about AI. That is the substantive destination of the talk: developers sharing concrete experiments in a craft whose tools, habits, and division of labor are still changing.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
The historical announcement of Gemini 3 Pro powering smart mode, including early evaluation results and known integration issues.
The original rush-mode design, with examples illustrating when a faster, cheaper model helps and when retries erase those advantages.
Amp's historical Oracle configuration and example prompts for delegating difficult planning, debugging and review.
An introduction to Amp's subagent for finding dependency implementations and examples across GitHub repositories.
The original editor review workflow: select commits, read a summary, follow a change tour, and navigate or edit diffs.
Updates since the talk
- Amp Free Is Ad-FreeArticle
Amp's later decision to remove advertising and revise its free-usage offering.
The announcement of Amp's move away from its VS Code and Cursor extensions toward the CLI.
Full transcript
Loading transcript…