Overview of Exploring with agents (Interview)
This episode features Adam Stacoviak talking with Amelia Wattenberger — designer, data visualization expert, former GitHub Next team member, and now working on Intent at Augment Code — about how AI agents are reshaping software development. The core idea: agents make the first 70% of building software much faster, but they can make the last 30% — polish, coordination, correctness, and finishing — feel harder than ever. The conversation explores the changing developer identity, the shift from autocomplete to chat to CLI and back to UI, and why the next generation of developer tools may need to revolve around workspaces, not just chat threads.
Key Themes and Takeaways
The arc of developer tooling
Amelia sees the AI tooling evolution as a coherent arc:
- Autocomplete → helpful, but still familiar
- Chat → asking models about codebases
- Tool use / code generation → agents writing code
- CLI-first workflows → developers and agents working in terminals
- UI and workspace-based tools → a return to structured interfaces for managing complex work
Her point is that the industry has changed quickly, but also in a logical sequence.
AI speeds up prototyping, but finishing is harder
A major theme was the idea that agents dramatically compress the early phases of work:
- Rough prototypes appear almost instantly
- It becomes easier to explore many directions
- But the “finish” phase grows more important and more difficult
Amelia described this as the point where developers have to decide whether to keep pushing a prototype into a polished product, because agents make it easy to generate more ideas before fully resolving the first one.
Developer identity is shifting
Both Adam and Amelia talked about an identity crisis for developers:
- Are we builders, designers, editors, orchestrators, or tastemakers?
- If agents can generate code, what remains distinctly human?
- The answer, in Amelia’s view, is taste, judgment, framing, and product intent
She emphasized that the value shifts from “can you produce code?” to “can you decide what should exist?”
Intent and the Workspace Model
Why workspaces matter more than chat threads
Amelia explained that Intent is built around the idea of a workspace as the main primitive, not a chat conversation.
In this model:
- Each task gets its own workspace
- That workspace has its own git work tree
- It can contain specs, notes, browser context, and multiple agents
- Developers can switch between tasks without losing context
This is meant to solve a real problem: modern development involves Slack threads, issue trackers, docs, branches, local work, and browser output — all of which are hard to keep aligned.
One work tree per task, not necessarily per agent
A particularly interesting design choice:
- Some tools isolate one work tree per agent
- Intent instead leans toward one work tree per task
That allows multiple agents to collaborate inside a single task environment without losing visibility into each other’s work.
Special roles for agents
Intent uses “specialists” with different roles, such as:
- Coordinator
- Implementer
- Verifier
- PR reviewer
- UI designer
The default flow is:
- A coordinator writes the spec and breaks work into subtasks
- Implementers carry out the subtasks
- A verifier checks the result by running tests and inspecting the app
This is designed to keep agents aligned and reduce “toes stepping” between concurrent tasks.
Coordination, Trust, and Orchestration
Trust the model — but with structure
Adam described his own workflow as effectively “trust the model”:
- Ask for suggestions
- Review them quickly
- Ask for blind spots
- Then tell the agent to do it
Amelia’s response was more cautious: she doesn’t fully trust agents by default, but she does trust them enough to be useful when the workflow is structured well.
Orchestration is the next big frontier
The conversation repeatedly returned to orchestration as one of the hardest and most interesting problems in agentic software:
- Which tasks should be isolated?
- Which should share a workspace?
- How should multiple agents communicate?
- How much should the system expose about who is working on what?
Amelia suggested that the future may include more advanced patterns, such as:
- Coordinator → implementer → verifier flows
- Agent-to-agent critique loops
- Parallel task execution with visibility into shared context
Open Source, Docs, and Maintenance
AI may change the economics of open source
The episode also explored how agents could reshape open source:
- It may become easier to maintain documentation
- Maintainers could receive AI-generated updates or prompts from users
- Community feedback could be turned into structured tasks for agents
- Some of the burdens of open source maintenance may be automated
Documentation becomes more dynamic
Amelia referenced work at GitHub Next around Copilot for Docs / DocPilot, which explored:
- Grounded documentation from codebases
- Personalized walkthroughs based on a developer’s background
- Auto-generated docs that can be updated as code changes
- Using maintainers only when AI can’t infer the answer from code
Her broader point: docs don’t have to be static artifacts anymore — they can become part of a living system.
Big Ideas About Software in the AI Era
Software becomes cheaper to produce, so restraint matters more
One of the strongest insights in the interview was this:
If we can build almost anything quickly, then the real question becomes: what should we not build?
Amelia argued that when software generation becomes cheap:
- Scope creep becomes easier
- It becomes tempting to add too much
- Taste and restraint become even more important
Human intent still matters
Even with powerful models, Amelia believes software should still reflect:
- Human judgment
- Opinionated defaults
- Clear product intent
- A meaningful design process
The goal is not to replace thought, but to compress the distance between intention and implementation.
A higher level of abstraction
Both speakers compared the shift to moving “up the ladder of abstraction”:
- Code is no longer the only level of interaction
- Agents can work on specs, tasks, and workspaces
- Tools are starting to represent software at the meta level
- Developers increasingly manage systems of work, not just files of code
Notable Quotes and Ideas
- “Prototyping just got easier, but finishing got harder.”
- “The last 30% is the hardest part now.”
- “We need a new primitive: the workspace.”
- “What do we not build?” becomes the key product question.
- Taste and restraint are becoming more valuable as generation gets cheaper.
Best-Fit Summary
This interview is ultimately about how AI agents are changing what it means to build software. Amelia Wattenberger argues that the real challenge is no longer getting to a rough idea — it’s coordinating, polishing, and deciding what deserves to exist. Her work on Intent reflects that belief: instead of treating agents as chatbots that write code, she treats them as collaborators inside a workspace built around context, roles, and intentional product design.