Version 1 to version 2

The first generation of AI coding tools waited for us to begin typing. They predicted the rest of the line, generated a function, or explained an error. The developer remained in control of the sequence. AI made individual moments faster, but the shape of software development remained largely unchanged.

That era is ending faster than the category can name itself.

Cursor now describes a future in which fleets of agents work autonomously and has rebuilt its interface around managing them. Codex began as a cloud coding agent, became a standalone command centre, and now sits as a dedicated software-development view inside the wider ChatGPT desktop application. GitHub has launched a separate Copilot desktop app where several sessions can begin from issues and pull requests, run in isolated worktrees, use different models, and return changes through the organization's existing review process. JetBrains Air organizes the workspace around agents rather than files. Zed can host Claude, Codex, Copilot, Cursor, OpenCode, and other agents through an open protocol. HumanLayer puts research, design documents, plans, implementation, and review into one agentic environment. Windsurf has disappeared as an independent brand and returned as Devin Desktop, a cockpit for local and cloud agents.

Even the phrase **AI IDE** is becoming too small.

The editor has not vanished. It has been demoted from the whole product to one surface inside a larger system. The new competition is over the code surface, the agent harness, the project memory, the verification layer, the orchestration console, and the governance process that decides whether any generated work should be accepted.

The meaningful question is therefore no longer which model writes the strongest code. Models can be exchanged, routed, upgraded, self-hosted, or accessed through several products. The deeper choice is where the tool places human judgment. Does the human edit every change, describe an outcome, approve a plan, maintain the project's memory, supervise several agents, inspect their reasoning, review the resulting code, verify the running product, or merely decide whether the work is worth keeping?

Every AI development product is quietly assigning the human a different job.

*Updated July 29, 2026.*

The market has split into layers

Almost everything is now described as an AI coding agent, an agentic IDE, or an AI software engineer. The terms make the market appear more uniform than it is.

| Layer | Representative tools | What the product is really trying to become | |---|---|---| | Code surface | Cursor, Zed, Devin Desktop, Kiro, TRAE, Qoder, CodeBuddy, Antigravity | The place where a human can still inspect and directly shape the software | | Agent harness | Claude Code, Codex CLI, Grok Build, Copilot CLI, Junie, OpenCode, Cline, Kilo | The worker that reads, edits, runs, tests, browses, and uses Git | | Orchestration console | Cursor 3, Codex in ChatGPT, GitHub Copilot app, JetBrains Air, Devin Desktop, HumanLayer, Nimbalyst | The place for assigning, steering, comparing, and reviewing several tasks or agents | | App factory | Lovable, Replit Agent, v0, Bolt, TRAE Work | A system that turns an idea directly into running software | | Memory and specification | Kiro Specs, Qoder Repo Wiki, HumanLayer design documents, Augment Context Engine | The institutional memory and intent around the codebase | | Review and governance | GitHub, Qodo, GitButler, Cursor auto-review | The system that controls how agent-produced changes enter the product | | Testing and evidence | Antigravity, Cursor cloud-agent artifacts, Autify, CodeBuddy | The proof that generated software behaves as claimed |

A single product can occupy several rows. That overlap is the point.

The first AI coding products were attached to an editor. The current products are expanding outward until they surround the entire process. Editors are adding cloud workers. Terminal agents are gaining graphical workspaces. Git hosting platforms are becoming agent consoles. App builders are importing existing repositories. Specification tools are becoming memory systems. Review tools are becoming governance platforms. Testing tools are becoming autonomous operators.

The market is not converging on one interface. It is separating into three primary layers:

1. **The surface**, where a human can see and manipulate the work. 2. **The harness**, which gives a model tools, permissions, context, and a development environment. 3. **The control system**, which coordinates several agents, tasks, repositories, and decisions.

This explains why the same model can feel brilliant in one product and chaotic in another. The model is only one component. The harness determines what it can perceive and do. The control system determines whether its work remains understandable.

Cursor: the editor becomes an agent cockpit

Cursor remains the clearest expression of the AI-native editor, but Cursor itself is moving beyond that identity.

The original promise was proximity. The human saw the files, selected code, inspected diffs, accepted changes, changed direction, and intervened whenever the result felt wrong. This remains especially valuable when the work is visual, exploratory, or difficult to specify in advance. A spacing adjustment, interaction detail, component refactor, or ambiguous frontend problem benefits from a tight loop between intention, implementation, and perception.

Cursor 3 changes the centre of gravity. Its new workspace is explicitly built around agents, parallel work, multiple repositories, and handoff between local and cloud execution. The user can rise to a higher level of abstraction, then return to the IDE when direct intervention becomes necessary.

Cursor's cloud agents also have their own computers. They can run the software, use a browser, capture screenshots and video, and return artifacts with a pull request. The tool is no longer only predicting code inside the editor. It is creating an environment in which agents can operate the product they are changing.

This makes Cursor a useful model for the likely survival of the editor. The editor does not disappear. It becomes the **recovery surface**.

When the agent understands the task, the human can remain at the orchestration level. When the agent becomes confused, produces an incoherent abstraction, or misses the visual point, the human can descend into the files and take control.

Its original vibe was:

Its emerging vibe is:

Several agents are building this. I can enter the code whenever I need to.

Zed: the editor as a neutral host

Zed represents a different possibility. Instead of trying to own one permanent agent, it is becoming an environment in which several agents can operate.

Zed distinguishes between its native agent, external agents connected through the Agent Client Protocol, and terminal threads that preserve an agent's original command-line experience. Claude, Codex, OpenCode, Copilot, Cursor, Gemini CLI, and other compatible agents can appear inside the same editor while retaining their own authentication, billing, tools, and configuration.

This separation matters.

The editor no longer has to be fused to one model company. The agent no longer has to build an entire graphical development environment. The user can choose a surface for navigation, editing, review, and parallel threads, then choose a different harness for each type of work.

Zed is therefore less interesting as another Cursor competitor than as a possible neutral layer between editors and agents. Its Agent Client Protocol is an attempt to make coding agents portable in the way the Language Server Protocol made language intelligence portable.

That creates a different human role. Cursor asks the user to trust Cursor's integrated system. Zed asks the user to assemble a system from replaceable parts.

The advantage is freedom. The cost is responsibility. Someone still has to decide which agent, model, subscription, permission system, and context source should handle the task.

Keep the editor. Replace the intelligence whenever necessary.

Claude Code: the harness as a senior engineer

Claude Code helped establish the terminal as a natural environment for coding agents. The terminal already contains the repository, shell commands, package managers, test runners, deployment tools, and Git. Giving an AI access to that environment turns it from a text generator into an actor capable of completing a sequence.

Claude Code can inspect a repository, edit files, run commands, execute tests, use Git, connect to external tools, and work through terminal, IDE, desktop, browser, and remote surfaces.

Its most important contribution may not be the terminal interface itself. It is the idea of the **agent harness** as a product.

A model alone does not know how to explore a repository, preserve context, ask for permission, recover from a failed command, use a subagent, follow project instructions, or decide when to test. The harness turns model intelligence into software-development behavior.

Claude Code is particularly useful when the problem is ambiguous:

- Why does this codebase behave this way? - Which part of the architecture is actually responsible? - What will break if this abstraction changes? - Why was the apparently simpler solution rejected? - How can the system be simplified without losing its original intent?

The product imagines the human as a senior engineer who supplies context, describes the problem, and judges the result.

Its vibe remains:

Codex: development becomes one mode inside a wider work system

Codex has evolved beyond a terminal agent into a multi-agent engineering workspace.

It can isolate tasks, run them in parallel, connect them to reusable skills, use local and cloud environments, work with repositories and terminals, and return completed changes. The original Codex app explicitly described itself as a command centre for agents.

The newer shift is organizational. Codex is now a dedicated view inside the ChatGPT desktop application, beside general chat and longer-form Work. Its coding workflows and history remain separate, but software development now sits inside a broader environment for research, documents, analysis, and operational work.

That is a larger move than a product rename.

It suggests that coding is becoming one specialized mode inside a general system for delegated knowledge work. A task may begin as market research, become a product specification, move into Codex for implementation, return to Work for documentation, and connect to external tools through the same plugin system.

- implement this feature and add tests - investigate and fix this build failure - upgrade a dependency across the repository - audit accessibility across a set of routes - compare several implementation approaches - prepare a pull request with the completed change

The important shift is psychological. Cursor invites the user to remain inside the act of making software. Codex invites the user to define an outcome and delegate execution.

GitHub Copilot app: the repository becomes the command centre

GitHub's standalone Copilot app is one of the clearest new entrants because it does not begin with the editor.

A session can begin from an issue, pull request, prompt, or previous session. Several sessions can run in parallel across repositories, each isolated in its own branch and worktree. The user can review the diff, validate the result in an integrated terminal and browser, and open a pull request that passes through the team's existing checks and merge requirements.

The app also supports canvases, cloud automations, model choice, external tools through MCP, and bring-your-own-key providers, including local or self-hosted models.

GitHub's argument is not that developers need another place to type code. It is that agentic development should begin where the organization's work is already described, reviewed, governed, and merged.

That gives GitHub an advantage few standalone IDEs can copy. It already owns the social and procedural layer around code. Issues express intent. Pull requests express proposed change. Checks express automated evidence. Reviews express human judgment. Permissions express authority.

The Copilot app turns those existing objects into entry points for agents.

Its vibe is:

Start from the issue. End at the governed pull request.

This may make it less exciting for an individual developer than the newest experimental editor. It may make it much more powerful inside an organization.

JetBrains Air: the IDE company moves above the IDE

JetBrains spent decades building environments that understand types, symbols, frameworks, references, build systems, tests, and refactoring more deeply than a basic text editor.

Air uses that foundation but reorganizes the product around agents rather than around files.

It can host several coding agents, including agents from different providers, isolate their work, and give the user one place to delegate and inspect tasks. JetBrains has also backed the Agent Client Protocol, which means the company is not betting only on its own Junie agent.

This is strategically important.

The company best known for heavyweight IDEs is acknowledging that the primary interface may move above the editor. Yet it can bring its existing semantic understanding into that higher layer.

Air's advantage is not simply multi-agent tabs. It is the possibility that each agent receives real project structure rather than a pile of searchable text.

Its vibe is:

The agent should inherit the IDE's understanding of the project.

HumanLayer: the design document enters the IDE

HumanLayer begins from a problem that most agentic IDEs still treat as secondary: agents can produce a great deal of code before the team agrees on what the system should become.

The product describes itself as an AI IDE, collaboration platform, and set of building blocks for a software factory. Its workflow connects research, questions, design documents, plans, implementation, comments, and decisions. The user can remain at a high orchestration level, then inspect thinking messages, subagent calls, and individual code changes.

The important object is not only the file or chat thread. It is the evolving **design decision**.

In many coding-agent workflows, the plan disappears once implementation begins. The agent creates code, the human reviews the diff, and the reasoning that shaped the architecture becomes detached from the result. HumanLayer tries to keep those artifacts connected.

This gives it a sharper thesis than another VS Code fork:

Do not generate the implementation until the research, design, and constraints are strong enough to survive it.

HumanLayer imagines the human as an architect and reviewer, not merely a prompt writer.

Devin Desktop: Windsurf becomes an agent container

Windsurf should no longer be counted as a separate current product. On June 2, 2026, it became Devin Desktop.

That change is more than branding.

Windsurf began as one of Cursor's closest direct competitors. Its Cascade agent combined editor-based assistance, repository context, and autonomous changes. Devin Desktop keeps the IDE, but places it inside a wider command centre for local and cloud agents. It can support Devin and other ACP-compatible workers rather than requiring one proprietary intelligence.

The product lineage tells the story of the market in miniature:

1. Codeium began as an AI coding assistant. 2. Windsurf became an AI-native IDE. 3. Devin Desktop became an agent-management environment that still contains an IDE.

The editor was not replaced. It was absorbed.

Developers may not choose one permanent intelligence. They may choose an environment that routes different work to different agents. One agent may understand a legacy backend better. Another may be stronger at visual browser work. Another may be cheaper for repetitive migrations. Another may be trusted for security review.

The winning environment may be the one that makes those differences manageable.

Google Antigravity remains one of the most explicitly agent-first development products. It combines an IDE with an agent manager and emphasizes artifacts that show what happened.

Cursor's cloud agents are moving in the same direction by operating their own computers and returning screenshots, videos, and logs. The competition is no longer only over generation. It is over **demonstration**.

Kiro and Qoder: intent and memory become products

Kiro and Qoder respond to a weakness in vibe coding: an agent can produce a large amount of code before anyone has made the product or system coherent.

Qoder combines an editor with autonomous Quest work, persistent memory, specifications, worktrees, Knowledge Cards, and Repo Wiki. Repo Wiki continuously turns the codebase into structured documentation, reducing the need for every new session to rediscover the project from scratch.

Their philosophies overlap, but they emphasize different failures.

HumanLayer adds a third question:

Which decisions must remain connected to the implementation?

These tools may matter more than another slightly stronger coding model. A frontier model can be replaced. Project memory, design intent, rejected alternatives, and accumulated constraints are much harder to reconstruct once they disappear.

Grok Build: another terminal agent, but a revealing one

Grok Build entered the market in May 2026 as a terminal coding agent for professional software work.

It includes plan approval, clean diffs, plugins, skills, hooks, worktrees, headless use, and parallel subagents. Its feature list resembles the direction already established by Claude Code, Codex CLI, Copilot CLI, OpenCode, Cline, and Kilo.

That similarity is revealing.

The terminal agent is becoming a standard product form. The basic expectations are no longer surprising:

- inspect the repository - propose or approve a plan - edit several files - run commands and tests - create isolated worktrees - delegate to subagents - expose hooks and reusable skills - operate interactively or headlessly

The interesting competition is moving away from whether an agent can modify code and toward how its harness manages context, permissions, planning, recovery, and review.

Grok Build matters less because it invents a new interface than because another major model company has accepted the terminal harness as essential infrastructure.

TRAE, Qoder, CodeBuddy, Qoder CN, Baidu Comate, and CodeGeeX have been pulling more of the software process into one environment.

Qoder emphasizes repository knowledge, specifications, memory, and autonomous Quest tasks. Alibaba's China-focused Tongyi Lingma became Qoder CN and expanded into IDE, CLI, cloud-agent, and workplace surfaces.

Tencent CodeBuddy covers requirements, design, coding, debugging, previews, and deployment. It supports screenshots and Figma input, several agent modes, terminal workflows, browser interaction, and parallel tasks.

Baidu Comate has expanded from enterprise coding assistance toward agentic editing, terminal execution, browser operation, and connections between design material and code. CodeGeeX remains more model-oriented, with multilingual generation and deployment options that can fit controlled environments.

The Chinese pattern is workflow compression. Product planning, design, implementation, browsing, testing, deployment, and organizational knowledge are pulled together aggressively.

App builders are still a different species

Lovable, Replit Agent, v0, Bolt, and TRAE Work are frequently included in AI coding comparisons, but they begin from a different assumption.

Cursor assumes that code remains the working material. Claude Code assumes that a repository and development environment already exist. Codex assumes that an engineering outcome can be delegated. GitHub Copilot assumes that work begins as an issue or pull request.

Replit Agent can create, explain, repair, host, and deploy an application inside one environment. Lovable combines conversational creation, visual iteration, backend services, and deployment. v0 has expanded from interface generation toward full-stack applications and GitHub-connected workflows. Bolt combines generative models with a browser-based development environment.

Open protocols are separating the editor from the agent

The most important infrastructure change may be the separation of the agent from the surface that displays it.

Zed's Agent Client Protocol allows compatible agents to appear inside different editing environments. JetBrains supports the same direction. Devin Desktop can host ACP-compatible agents. Nimbalyst wraps agents such as Claude Code and Codex in a local-first visual workspace with files, tasks, sessions, diffs, and worktrees.

OpenCode, Cline, Roo Code, Kilo, and Aider make a related argument at the harness level. The model should be replaceable. Users should be able to choose providers, use local models, control permissions, and preserve their workflow after a commercial product changes direction.

This is the beginning of a stack.

The editor can be replaceable. The agent harness can be replaceable. The underlying model can be replaceable. The context provider can be replaceable. The testing and review systems can be replaceable.

The advantage is portability. The cost is assembly.

A proprietary integrated product can hide complexity and deliver a smoother experience. An open stack gives the user control over models, data, billing, and future migration. Neither approach wins automatically.

The larger point is that **model choice is becoming less important than system design**. Once several environments can host the same agents, the differentiator becomes how well they expose context, coordinate work, preserve decisions, and support review.

The market is already deleting its first generation

The category is moving so quickly that several products from the original AI-IDE wave are already gone or being absorbed.

Void, the open-source Cursor-style editor, is deprecated and its repository has been archived.

Firebase Studio has stopped accepting new workspaces and is scheduled to shut down on March 22, 2027.

Continue shipped a final 2.0 release, and its main repository is now read-only and no longer actively maintained.

Windsurf has become Devin Desktop.

The standalone Codex app has become the Codex view inside the wider ChatGPT desktop application.

These are not minor footnotes. They show how unstable the product boundary remains.

Some tools disappear because an integrated competitor moves faster. Some become infrastructure. Some are acquired. Some are folded into a larger work platform. Some survive only as open-source reference code.

Choosing an AI development tool is therefore also a choice about **exit cost**.

Where does the project memory live? Can agent instructions move elsewhere? Are tasks stored in open files? Can another agent read the same specifications? Can the user export conversations and decisions? Does the repository remain understandable without the product?

A workflow that produces code quickly but traps its context inside a disappearing interface may create a new kind of technical debt.

Generation creates an attention problem

This creates demand for GitHub's review process, Qodo's governance, GitButler's branch management, Cursor's auto-review, Autify's autonomous testing, Antigravity's evidence, and HumanLayer's connection between decisions and implementation.

A merged pull request is not the same thing as a durable contribution. More code is not automatically more value. A feature that passes generated tests may still violate the product's logic, accessibility requirements, security model, or operational reality.

The bottleneck is moving from code production to attention allocation.

The best development system may not be the one that lets a human supervise the most agents. It may be the one that knows which changes deserve human attention, which can be verified automatically, which should be rejected early, and which require a return to direct manipulation.

Cursor imagines the human as an active maker who can move between orchestration and direct editing.

Zed imagines the human as the assembler of a replaceable agent stack.

Codex imagines the human as a delegator who defines outcomes and distributes bounded tasks inside a wider work system.

GitHub Copilot app imagines the human as the owner of a governed issue-to-pull-request process.

JetBrains Air and Devin Desktop imagine the human as a manager of several agents.

HumanLayer imagines the human as an architect whose research, design choices, comments, and decisions must remain connected to implementation.

Qodo, GitButler, GitHub, and Autify imagine the human as a governor of a system that can produce changes faster than any one person can inspect them manually.

A visual interaction may require direct manipulation in Cursor. An ambiguous architectural problem may benefit from Claude Code or HumanLayer. A clear migration can be delegated to Codex. A GitHub issue can become a Copilot app session. An undocumented legacy repository may benefit from Qoder or Augment. A new product idea may begin in Lovable or Replit. A provider-neutral workflow may begin in Zed or Air. A regulated organization may prioritize private models, open harnesses, and enforceable governance.

Choose **Cursor** when you want the strongest balance between direct editing and parallel agent work, especially when visual iteration matters.

Choose **Zed** when you want a fast editor that can host several replaceable agents and model providers.

Choose **Codex** when the task has a clear finish line and can be delegated as an engineering outcome, especially when parallel work, skills, and a broader ChatGPT workflow matter.

Choose the **GitHub Copilot app** when work should begin from issues and pull requests and remain inside existing organizational controls.

Choose **JetBrains Air** when you want a provider-neutral agent console backed by mature semantic code intelligence.

Choose **HumanLayer** when research, architecture, design documents, and implementation decisions must stay connected.

Choose **Devin Desktop** when you want one surface for local and cloud agents while retaining a full IDE for intervention.

Choose **Kiro** when an ambiguous idea needs to become a specification before it becomes code.

Choose **Qoder** when an established repository needs persistent memory, documentation, and autonomous work.

Choose **Grok Build**, **OpenCode**, **Cline**, **Kilo**, or another terminal harness when command-line workflows, model choice, and composability matter more than a polished integrated environment.

Choose **Qodo**, **GitButler**, **GitHub**, or **Autify** when the bottleneck has moved from creating changes to reviewing, organizing, and proving them.

The useful unit is increasingly not one tool. It is a stack.

The development system is beginning to appear

A research and specification system can make the intent explicit.

A repository-memory system can preserve context and rejected alternatives.

An editor can refine the interaction and provide a recovery surface.

An orchestration console can distribute work across repositories and agents.

The first AI coding tools automated fragments of typing. The current generation is rebuilding the rest of the organization around software-producing agents.

The editor is being demoted, but it remains where ambiguity becomes visible and control can be recovered.

The model is becoming replaceable, but the harness determines whether intelligence turns into reliable action.

The agent is becoming more autonomous, but the orchestration system determines whether its work remains legible.

The most important product may not be the one that writes the most code. It may be the one that preserves the reasons behind the code, shows what the agents changed, proves that the result works, and makes reversal possible when the original idea turns out to be wrong.

- [The UX of Not Doing the Work](/blog/the-ux-of-not-doing-the-work) - [The Product Needs a Harness](/blog/the-product-needs-a-harness) - [The Browser Is Becoming the Agent's Body](/blog/the-browser-is-becoming-the-agents-body) - [Executable Drafts](/blog/executable-drafts) - [The Interface Is Now Part of the Answer](/blog/the-interface-is-now-part-of-the-answer)

This essay grew from Kris Haamer comparing AI development environments, coding agents, app builders, and the changing role of the editor. AI supported current product research, market mapping, comparison, drafting, editing, source gathering, and implementation. Kris directed the article toward the changing role of human judgment, expanded the comparison to new 2026 products and product deaths, and chose the final version for publication.