# The Emerging Skillset of Wielding Coding Agents

Beyang Liu, Sourcegraph / Amp | AI Engineer World's Fair 2025 | 35:06

Source: https://www.youtube.com/watch?v=F_RyElT_gJk
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/the-emerging-skillset-of-wielding-coding-agents
Published: 2025-06-30
Tags: agent-skills, agents, coding-agents, context-engineering, tool-use

## TL;DR
- Coding agents require new working habits because model capabilities have changed substantially in the past six months.
- Agents work better when developers give them detailed prompts, direct them to relevant context, and provide fast feedback loops.
- Experienced users treat agents as tools for code exploration, review, and parallel engineering work, while retaining responsibility for the code they ship.

## Summary
Beyang Liu argues that the disagreement about coding agents comes partly from developers using new systems with habits from earlier AI tools. He describes three eras: autocomplete based on GPT-3, chat and retrieval-based assistants, and agents that use tools and act across a codebase. Amp was designed for this agent era with a small interface, automatic file edits, a VS Code extension, and a CLI. Liu's practical advice comes from Amp's power users. They write long prompts, provide repository-specific instructions, build fast test and browser feedback loops, use agents to understand unfamiliar code, and run several tasks in parallel. A live demo shows Amp finding a Linear issue, editing a production codebase, running tests, and correcting an incomplete first pass. Liu is honest that agents still need human direction and review. His claim is that using them well is becoming an engineering skill that requires practice, much like learning an editor or programming language.

## Key ideas
### Developers are divided because they are using agents at very different skill levels
[00:31](https://www.youtube.com/watch?v=F_RyElT_gJk&t=31s)
Liu opens with the split in opinion around coding agents. Jonathan Blow and Alex Albert are presented as skeptical, while Jesse Frazelle, Eric S. Raymond, and security engineer Thomas Tachek describe the tools as useful. Liu says the difference may partly come from the user's own ability and working method. Even among people who find agents useful, there is disagreement about whether they belong in production codebases or only in small edits, front-end work, and weekend projects. He connects this disagreement to the fast-changing technical conditions around the tools.

### Old coding-assistant habits became outdated after a rapid change in model capabilities
[03:09](https://www.youtube.com/watch?v=F_RyElT_gJk&t=189s)
Liu says the most common mistake is using coding agents the same way developers used AI coding tools six months earlier. He describes the recent change as a "step function transition" in model capabilities. In his account, best practices normally remain useful for years, but the pace of change has made that assumption unreliable. Developers have to learn new interaction patterns rather than simply applying autocomplete or chatbot habits to a system that can use tools and act on a codebase.

### AI coding tools have moved from autocomplete to chat, retrieval, and agents
[04:07](https://www.youtube.com/watch?v=F_RyElT_gJk&t=247s)
Liu divides AI coding into three eras. In the GPT-3 era, text completion produced copilot and autocomplete tools. The user typed code and the system suggested what came next. ChatGPT and GPT-3.5 introduced instruction-following, so developers could ask questions in natural language. The next step was copying code from a repository into the chat so the model could pattern-match against it, which led applications toward retrieval-augmented chatbots. The current agent era uses models with tools, requiring a different application architecture.

### An agent should make file changes directly while the developer steers from above
[07:24](https://www.youtube.com/watch?v=F_RyElT_gJk&t=444s)
Liu's first design principle is that an agent should edit files without asking for approval at every turn. If an agent proposes a wrong change, he says it has already done the wrong thing and wasted time. The developer should guide the overall task and review the result instead of micromanaging each edit. He also questions whether agents need a thick VS Code-style client for context management and applying changes. Amp therefore has a small VS Code extension and a command-line client. Both expose the same tools, while the CLI can be scripted and composed with other tools.

### Amp uses tools and subagents to gather context before changing production code
[13:01](https://www.youtube.com/watch?v=F_RyElT_gJk&t=781s)
In the demo, Liu asks Amp to find a Linear issue about changing the icon for the Linear connector and implement it. Amp can read and edit files, run Bash commands, use Playwright and Postgres through MCP, and query Linear through its MCP server. Its search operation runs as a subagent with several search methods. Amp reads relevant front-end and server files, creates a task list, edits incrementally, and checks diagnostics. The first pass changes one page but misses another because the required configuration data is restricted on non-admin pages. After Liu points out the discrepancy, Amp traces the existing handling of non-secret configuration and fixes the settings page.

### Power users write detailed prompts and build explicit feedback loops
[23:03](https://www.youtube.com/watch?v=F_RyElT_gJk&t=1383s)
Amp's experienced users tend to write long prompts with the context they would give a colleague. Liu says the team changed Amp's input so Enter creates a new line and Command-Enter submits, encouraging more detailed instructions. Users also tell the agent exactly how to build, test, or lint unusual parts of a production repository. For front-end work, Liu recommends a fast loop built from Playwright and Storybook. The agent can edit a component, open it in a browser, capture the result, and iterate without reloading the whole application.

### Agents can help developers understand code and review larger changes
[27:48](https://www.youtube.com/watch?v=F_RyElT_gJk&t=1668s)
Liu rejects the idea that agents necessarily make developers less familiar with their code. He describes a new developer using Amp to learn how parts of the system connect, with diagrams and links to specific code. He applies the same idea to code review. For a large diff, he asks the agent for a high-level summary and then asks where a senior developer would begin reviewing. This reduces the effort needed to find an entry point and gives him more time to inspect the actual changes. He still treats the human as responsible for the code that ships.

### Subagents and parallel work let experienced users handle longer tasks
[29:27](https://www.youtube.com/watch?v=F_RyElT_gJk&t=1767s)
Liu says subagents are useful for longer tasks because they keep a specific subtask's context from filling the main agent's context window. He gives an example of a model with a 200K context window that starts degrading around 120K or 130K tokens. A subagent can isolate work such as implementing a small feature. He also describes power users running several agents at once, including Jeff Huntley working on different parts of a compiler. This approach depends on good prompts and reliable feedback loops, because the user may start several tasks and leave them running.

## Notable quotes
- "The number one mistake that people are using with coding agents right now is they're trying to use coding agents the same way they're using AI coding tools six months ago." (03:27)
- "The agent should just make edits to your files." (07:24)
- "You should be using them to do much more thorough code reviews more quickly." (31:39)
- "The human is still ultimately responsible for the code that you ship." (31:47)
- "It is a high ceiling skill." (33:27)

## Tools & references mentioned
- Sourcegraph
- Amp
- Jonathan Blow
- Alex Albert
- Jesse Frazelle
- Docker
- Eric S. Raymond
- Thomas Tachek
- Jeff Huntley
- Canva
- Cursor
- ChatGPT
- GPT-3
- GPT-3.5
- GPT-4
- Claude 3
- Claude 4 Sonnet
- Linear
- MCP
- VS Code
- Playwright
- Postgres
- Storybook
- Kubernetes
- Braid

## Who should watch
- You are using coding agents as autocomplete or chat assistants and want to understand what changes when the system can act on a repository.
- Your team wants agents to work on production code but needs better prompting, testing, browser checks, or repository-specific feedback loops.
- You review large pull requests or explore unfamiliar code and want to use an agent without giving up responsibility for the result.

## Related talks

- [Agentic Engineering: Working With AI, Not Just Using It](https://aietalks.com/talks/agentic-engineering-working-with-ai-not-just-using-it) (Brendan O'Leary, Kilo Code, 27:03)
- [Self Coding Agents](https://aietalks.com/talks/self-coding-agents) (Colin Flaherty, Augment Code, 17:23)
- [Software Development Agents: What Works and What Doesn't](https://aietalks.com/talks/software-development-agents-what-works-and-what-doesnt) (Robert Brennan, OpenHands, 16:46)
- [How Coding Agents Change Software Development Forever](https://aietalks.com/talks/how-coding-agents-change-software-development-forever) (Hailong Zhang, 08:50)
- [Developer Experience in the Age of AI Coding Agents](https://aietalks.com/talks/developer-experience-in-the-age-of-ai-coding-agents) (Max Kanat-Alexander, Capital One, 18:20)