← All posts

Perspective ·

ADE vs. IDE: What Changes When the Agent Does the Typing

An IDE is built to help you write code. An agentic development environment is built to help you direct, check and run agents that write it. Here is where the two differ, point by point.

Two glass objects on a dark studio floor, a single thin glass bar like a text cursor on the left and a ring of small glowing glass spheres on the right

An IDE and an agentic development environment can look alike. Both have a file tree, a terminal and a model. The difference is who they are built for. An IDE is built around you writing code. An ADE is built around AI coding agents "as first-class participants rather than as an add-on,"1 writing code while you decide what they do and whether to keep it.

That one difference changes most of the design.

The short version

IDE ADE
Main unit of work A file and a cursor A task, with an agent, a checkout and a result
Your main job Writing and editing Directing, reviewing and approving
What the model does Suggests text where you're typing Reads, runs commands, edits files and reports back
How many at once One person, one cursor Several agents in parallel
The key control Undo Approval before an action, and a record after it
Where it runs Your machine, your editor Your machine, other machines, the cloud, your phone

The unit of work moves from the file to the task

In an IDE, everything is organized around open files. Tabs are files. Search finds lines in files. Even AI completion works on the file you have open.

In an ADE you hand over a goal: "make the failing tests pass", "add rate limiting to the login route". The agent decides which files to read and change. The tool's job is to track the task, show each step the agent takes, and show the result as something you can review. In Warp's description, the agent can "plan a task, execute a sequence of commands or edits, observe the result, and adjust."1

Your job moves from writing to reviewing

When the model only suggests text, you review each suggestion as it appears, and the editor's tools are enough. When the model acts, you are reviewing commands it wants to run and changes it already made across several files. That needs different tools: a clear view of each action before it runs, a diff of everything a task changed, and a way to send notes back.

The key control moves from undo to approval

In an editor, a mistake costs a keystroke. You undo it. An agent with a shell can do things undo can't reach: delete a folder, force-push a branch, drop a table.

So an ADE needs a gate between the agent and the machine. It decides which actions run on their own and which wait for a person. It keeps a record of what ran and who allowed it. It also needs a way to stop everything at once. In an IDE this layer barely exists, because the person at the keyboard is the gate.

One cursor becomes many agents

A person can only type in one place. An agent doesn't need your cursor, so nothing stops you running several. In practice that needs isolation. Two agents in one checkout end up editing the same files. ADEs give each agent its own git worktree, a second checkout of the same repository, so each one works on its own branch.2

Once agents run in parallel, you need a queue too: a list of tasks they can pick from, with some way to stop two agents claiming the same one.

Context moves from the open file to the whole environment

An IDE's model sees what's open. An agent fixing a real bug needs much more: the terminal where the error printed, the running dev server, the browser showing the broken page, the logs on a remote host. An ADE gives the agent tools for all of it, not just the editor buffer.

Standards made this practical. The Model Context Protocol lets an environment offer tools to any agent that speaks it, so the same tools serve several agents.3

The workspace leaves the desk

An IDE runs where you sit. An agent can keep working after you stand up. So ADEs reach past one machine: a cloud box an agent can work in while your laptop sleeps, and a phone that can answer an agent's question when you're away.

The IDE doesn't go away

None of this makes the editor obsolete. You still read code carefully, step through a debugger and make the small change faster than you can describe it. An ADE changes where most of the typing comes from, not whether you understand the code. Many developers will keep an editor open beside their ADE for exactly that.

What this looks like in TRMNLY

Every row in the table above has a concrete answer in TRMNLY: approval postures and standing rules, worktrees and a task board, an MCP server, a cloud workspace and an iPhone app. The next post, TRMNLY is an agentic development environment, goes through them one by one.

Sources

  1. 1.Warp, "What Is an Agentic Development Environment (ADE)?" warp.dev
  2. 2.Git documentation, "git-worktree: Manage multiple working trees." git-scm.com
  3. 3.Wikipedia, "Model Context Protocol." en.wikipedia.org/wiki/Model_Context_Protocol