The most important interface in software is gaining a new operator. For decades the only operator was a human being, and the IDE and the browser were built for that operator alone. They now have a second one, the agent, and it is taking the larger share of the work. Coding agents write and test code; computer use agents operate software. Adoption is already deep: 84% of developers use or plan to use AI tools, and a study in Science estimates AI wrote 29% of Python functions in the United States by the end of 2024. Which tool yields first is an open question. That the human share of both is shrinking is not.
The IDE is a workbench for a human writer: syntax highlighting for the eye, autocomplete for the hand, a debugger for a mind that can hold only so much of a program at once. An agent needs none of it. It reads code as data, generates it directly, and checks its work by running it, which is why code may yield first: it is structured, testable, and announces its own failures. The newest tools show the direction. OpenAI’s Codex app and the GitHub Copilot app do not open on a code editor or a file browser; the interface is a conversation and a list of tasks, with the code sitting behind the work, available when a human wants to look. OpenAI said it plainly: “existing IDEs and terminal-based tools are not built to support this way of working.“
The browser may take longer, because the web resists: pages are laid out for eyes, and they sit behind logins, bot checks, and advertising built to separate people from programs. Computer use agents are the workaround, clicking and scrolling like people because the web still demands a person. But the ground is already shifting. Automated traffic reached 51% of all web traffic in 2024, passing human traffic for the first time in a decade, and Pew Research found that when an AI summary appears in search results, users click a link 8% of the time, against 15% without one. Sites are building agent-readable versions of themselves, structured interfaces, and agent checkout. When enough doors exist, the browser stops being where transactions happen, and what remains for the human is intent and verification: state what you want, then check the diff, the tests, the receipt.
So build for the post-IDE, post-browser era. Build for the agent as the primary user: an interface for an agent is a contract, typed inputs, structured outputs, clear errors, a way to undo, delivered as an API, a command line, or a tool server; the Model Context Protocol already has more than 10,000 public servers. Build verification as the product: diffs, traces, audit logs, approval gates, reversible actions. Build documentation for models, and build the web to be called, not just visited, because advertising needs eyeballs and the eyeballs are leaving; payment for completed work is what replaces it, and Mastercard, Visa, and Stripe are already building the agent payment rails. The agent layer will be owned by someone, and whoever owns it sets the terms for everyone else. Which tool fades first, nobody knows. That both fade is the part worth acting on, and the only choice left is whether you design for what replaces them, or get dragged into it.