Coding Interfaces

The interface you drive AI through keeps adapting as autonomy rises -- from completions in the editor, to side chat, to agents on your code, to background agents in the cloud, to spec-, chat- and board-native surfaces. "The IDE is dead" misses it: more autonomy needs a better review UI, not none.

The Pattern

"It's only been ~6 months but we've really sprinted from AI-IDE to CLI to background agents as the UX for AI-driven development." -- brexton (source)

The interface you drive AI through keeps adapting as the agent does more. Each jump in autonomy spawns a new surface, and your job shifts further from typing toward directing and reviewing. The rough arc:

• In the editor -- completions (autocomplete), then a chat panel on the side, then a chat that edits your actual code.
• Parallel and session-based -- several agents working the codebase at once, and separate sessions per feature, pushing UIs toward managing sessions rather than files.
• Off your machine -- background and cloud agents running long tasks not on your laptop, reporting back asynchronously; Cursor 2.0 pulled this into a mainstream IDE with a multi-agent layout and git worktrees (Cursor 2.0).
• Spec-native -- the artifact moves into the tool: writing the spec becomes part of the IDE (Amazon's Kiro generates requirements and a design doc before any code, Böckeler).
• Chat- and team-native -- the conversation moves into Slack and group chat, where the agent becomes a coworker and collaboration goes multiplayer. Cognition runs Devin in Slack (Devin / Latent Space); Anthropic's Claude Tag joins a channel as a shared, asynchronous @Claude the whole team delegates to (Claude Tag) -- "a new paradigm... significantly more 'inline' with all the other human activity org-wide," as Andrej Karpathy put it (Karpathy).
• Board-based -- task boards that track many agents kanban-style, the human accepting "proof of work" rather than watching keystrokes (OpenAI Symphony), with notifications standing in for the loop you used to watch.

It is not a clean replacement -- people still drop back to the editor for line-by-line work. It is a widening menu, and the constant is direction: each surface trades a little more typing for a little more reviewing.

Why It Matters

"The IDE is dead" misses the point. As agents take on more, you do not need less interface -- you need a better one, pointed at a different job. The bottleneck moves from writing code to reviewing it: confirming a long autonomous run did the right thing. The frontier is the review surface -- diff views, test and video evidence that "it works," PR conversations -- not the absence of one; Cognition spends much of its product effort exactly here (Devin / Latent Space).

This is the moldable-development point in new clothes: software is "shapeless," and "tools provide the shape" we reason about it through (Tudor Girba / feenk). The more an agent does, the more the interface has to re-present that work in a form a human can actually judge. So the pattern is not a winning surface but an adapting one: as autonomy climbs through layers -- assist, delegate, dispatch -- the interface reshapes around review and direction. The dispatch end is what loop engineering automates (Jazz Tong).

Match the surface to the stakes and to how much you need to understand the result -- the from coder to orchestrator shift made concrete. More autonomy is not always better; it just moves where your attention is spent, from writing the code to trusting it.

Last reviewed: 2026-06-25