A year of AI coding / 05
The IDE is becoming a place to delegate
Agent-oriented development environments need to make scope, evidence, and approval as clear as the code they help produce.
By Grafty team · · 3 min read
Written in .
An editor is good at showing you a file and letting you change it. Delegating a task requires a different view. You need to know what the worker thinks the task is, what it has touched, and whether it is waiting for something only you can decide.
Google introduced Antigravity on November 18, 2025 as an agentic development platform with an IDE, browser control, and asynchronous interaction. Its launch announcement described agents planning and executing software tasks across those surfaces.
The interesting change is the relationship between the developer and the environment. Once an agent can edit files, run commands, and exercise the application in a browser, the interface has to support supervision of that sequence. A chat panel alone is a limited view of the work.
Open full-size diagram Evidence belongs beside the result
Suppose an internal order management app needs to let an operator cancel an order before fulfillment. An agent can show a screenshot of a cancel button and report that the task is complete.
That is not enough evidence. The reviewer needs to see whether the server checks the order state, whether cancellation is safe to retry, and whether the operation records who requested it. The browser view helps establish that the control is usable, but it cannot establish all of the backend behavior.
A useful environment should make it easy to inspect the relevant diff, the tests run against it, and the application state used during browser verification. Ideally, those artifacts refer to the same revision. Otherwise the screenshot may describe an earlier build and the passing tests may predate the last edit.
There is a practical design question here: how much activity should the interface show? A full stream of shell output is available evidence, but it is not always a good status view. We would want a summary of current work with a path to the underlying commands and results. Hiding failed attempts behind a confident final message is worse than showing too much.
Open full-size diagram Approval needs a clear meaning
An agent asking "Can I continue?" is not a very useful approval request. Continue to do what, with which identity, against which environment?
The developer should be able to distinguish permission to install a development dependency from permission to run a database migration. The environment should enforce that distinction, rather than relying only on the model to remember it.
For enterprise work, browser access deserves the same attention as terminal access. An authenticated browser can expose internal data or perform real operations. A test account and a staging dataset provide a much safer place for automated verification than a developer's everyday session.
We also want interruption to preserve a coherent handoff. If someone stops the agent during a task, the next view should explain which changes are complete and which remain partial. That matters more than making every interaction look uninterrupted.
An agent-oriented IDE has a chance to improve this experience because it can connect the task, the code, and the running application. But putting more actions in one interface also makes its permission boundary more important.
The test is straightforward: after the agent finishes, can another engineer understand what happened and decide whether the result is safe to use? If the interface makes that easier, delegation has become more practical. If it only hides the activity behind a progress indicator, the underlying review work is still there.