← All posts

Perspective ·

From IDE to ADE: Why Development Environments Are Being Rebuilt Around Agents

For fifty years the development environment was built around a person typing. Coding agents changed who types, and a new kind of tool, the agentic development environment, grew up around them.

A glass keyboard key on a dark studio floor, with a small glowing cyan sphere rising out of it on a thin stem of light

For about fifty years, the development environment has been built around one assumption: a person is typing the code. Coding agents broke that assumption, and the tools are being rebuilt around the new situation. The new kind of tool has a name: the agentic development environment, or ADE.

The IDE put everything a programmer touched in one place

The integrated development environment is older than the personal computer. Softlab Munich built the first prototype of Maestro I, then called PET, in 1974. Maestro I is usually counted as the first IDE, and it reached 22,000 installations worldwide.1 The idea was simple: put the editor, the build and the tools a programmer uses in one environment instead of several.

Every later generation kept that shape. The tools got smarter, but the person at the keyboard stayed at the center. In 2016 Microsoft, Red Hat and Codenvy announced the Language Server Protocol, a common way for editors to get code completion, go-to-definition and refactoring from a language server.2 That made language smarts portable between editors. It didn't change who was writing.

Then the editor started suggesting

GitHub announced Copilot on June 29, 2021, as a technical preview in Visual Studio Code. It was described as "a new AI pair programmer" that suggests whole lines or whole functions from the code around the cursor.3

Copilot changed how fast code arrived, but not the arrangement. The person still typed, and still accepted or rejected each suggestion in place. The model wrote inside the editor, one completion at a time.

Then the model started acting

Two releases a few months apart changed that.

In November 2024, Anthropic introduced the Model Context Protocol, MCP. It is an open standard for connecting models to outside tools and data, so an application can offer tools, resources and prompts that a model can use.4 OpenAI and Google DeepMind adopted it in the months after.4

On February 24, 2025, Anthropic released Claude Code as a limited research preview. Anthropic described it as "an active collaborator that can search and read code, edit files, write and run tests, commit and push code to GitHub, and use command line tools."5 It used the command line as its interface rather than plugging into an editor.9

Together they changed the job. The model was no longer suggesting text for a person to accept. It was taking actions: running the tests, reading the failure, changing three files and running the tests again. The person's job moved from writing each line to deciding what should happen and checking what did.

The environment had to change too

An environment built for a person typing in one file doesn't fit an agent working through a task. The gaps showed up quickly.

  • Actions need a gate. An agent that can run commands can run the wrong one. Something has to sit between the agent and the machine, decide what runs without asking, and record what ran.
  • The unit of work is a task. People stopped asking an agent about a line and started handing it a goal. The tool has to track that goal, show the agent's steps, and show the result as a diff you can review.
  • Agents run in parallel. A person has one cursor. An agent doesn't need one, so it's natural to run several. They need separate checkouts so they don't edit each other's files.
  • The agent needs the whole environment. Running servers, terminals, a browser, logs, other machines: an agent that can only see the open file can't debug much.

Someone gave it a name

In June 2025, Warp released Warp 2.0 and called it an Agentic Development Environment, built from four parts: Code, Agents, Terminal and Drive.6 Warp's own definition is a development tool "built around AI coding agents as first-class participants rather than as an add-on."7 It draws the line against tools where every agent action still goes through inline suggestions approved "keystroke by keystroke."7

The term has spread since, and more tools now describe themselves this way. Whatever the label, the common thread is the shift above: the environment is organized around agents doing work and a person supervising it, not around a person typing.

Where TRMNLY fits

TRMNLY is an ADE built on a terminal. It is built on Ghostty, and the agent works through the same panes, files and commands you do.8 That is the right starting point, because the terminal is where coding agents already do their work. The next two posts cover how an ADE differs from an IDE and what being an ADE means inside TRMNLY.

Sources

  1. 1.Wikipedia, "Maestro I." en.wikipedia.org/wiki/Maestro_I
  2. 2.Red Hat press release, "Red Hat, Codenvy and Microsoft Collaborate on Language Server Protocol" (June 27, 2016). redhat.com
  3. 3.Wikipedia, "GitHub Copilot." en.wikipedia.org/wiki/GitHub_Copilot
  4. 4.Wikipedia, "Model Context Protocol." en.wikipedia.org/wiki/Model_Context_Protocol
  5. 5.Anthropic, "Claude 3.7 Sonnet and Claude Code" (February 24, 2025). anthropic.com
  6. 6.SD Times, "Warp 2.0 evolves terminal experience into an Agentic Development Environment" (June 25, 2025). sdtimes.com
  7. 7.Warp, "What Is an Agentic Development Environment (ADE)?" warp.dev
  8. 8.Learn TRMNLY, "A tour of the window." trmnly.dev/learn/tour-of-the-window
  9. 9.DevClass, "Anthropic previews Claude Code: agentic coding capable but costly" (February 27, 2025). devclass.com