Every IDE is a chat interface now. The editor is the side panel.

A screenshot of the 2018 layout is familiar: VS Code, a tree on the left, a tabbed file in the middle, a terminal at the bottom. The middle is where the work happens. The rest is scaffolding.

Look at the same engineer's screen in 2026. The tree on the left is still there. The terminal is still at the bottom. There is a new panel on the right, taking up a third of the horizontal space, where a conversation is in progress about the code. The file in the middle has shrunk. It is no longer the centre of attention. It is one of two things the engineer is looking at, and arguably the less important of the two.

What got built in four years

The shape of a code editor was stable for almost two decades. VS Code launched in 2015 with the layout described above. JetBrains products had the same layout in a slightly different colour scheme. Sublime, Atom, Vim with plugins, Emacs with packages: same layout. The text was the canonical artefact. Everything else served it.

Then GitHub Copilot launched in 2021 as autocomplete-with-LLM. For two years it stayed inside the autocomplete metaphor. You typed, ghost text appeared, you accepted or rejected. The editor was unchanged. Copilot was a feature inside it.

Cursor, one of the earliest products to break the pattern, launched in 2023 by forking VS Code and treating the chat panel as a first-class surface. The text buffer was no longer the only place you typed. You could type into the chat, point at code regions, and the chat would write the code back. The completion model and the conversation model were merged. By 2025 Cursor raised at a $9.6 billion valuation and was widely used inside companies that had standardised on VS Code for the previous decade.

Windsurf, from Codeium, shipped Cascade in late 2024, an agent interface that could take multi-step actions across the codebase from a single instruction. Zed added an Assistant panel in the same period. Microsoft's own VS Code, the host product Cursor had forked from, integrated chat as a first-party surface that's now on by default.

Four years. From "autocomplete with an LLM" to "the chat panel is what you spend the most time looking at, and the editor is the thing the chat panel writes into."

What changed inside the workflow

The Stack Overflow Developer Survey for 2024 reported that 76% of respondents use or plan to use AI tools in their development process. The number that matters more, which the survey does not capture cleanly, is the percentage of an engineer's day spent typing into the chat panel versus typing into the file.

For some workflows engineers now spend more time in the chat panel than in the file. Reading code, debugging, scaffolding a new module, drafting a migration, writing tests, generating SQL, drafting commit messages: all of these have a chat-first version that competes with the editor-first version, and the chat-first version is often faster.

Engineers still write code. They originate less of it than they used to. The pattern is:

The engineer reads the existing code in the file. They have a question or an instruction. They type the question or instruction into the chat panel, sometimes with a pointer to the code region. The chat panel writes back a draft. The engineer reviews the draft, sometimes accepts it, sometimes iterates on it. The accepted draft lands in the file.

The file is still important. It is no longer where typing happens.

What this means for the editor

The IDE companies who built the previous decade of layout know this has happened. JetBrains shipped its AI Assistant. VS Code's Copilot Chat is on by default. Even Vim plugins for LLM interaction exist. The platforms that did not adapt have been losing developers to Cursor, Windsurf, and the integrated VS Code Copilot interfaces.

The interesting thing is what the editor surface itself is becoming. It is becoming a viewer. The keyboard shortcuts that were optimised for fast text entry, such as vim motions, multi-cursor, and snippet expansion, matter less when the bulk of new text arrives as a chat completion rather than as a sequence of keystrokes. The shortcuts that matter now are different: accept-suggestion, reject-suggestion, ask-about-this-block, refactor-with-prompt.

What we have lost

There is a thing worth naming here. The editor used to host focused, sustained attention. You opened a file. You read it. You thought. You made an edit. You read the result. The flow was personal. The work was internal.

The chat panel changes that flow. It introduces a second voice in the room. The engineer is no longer alone with the file. They are negotiating with a counterparty that is fast, fluent, confident, and frequently wrong in ways that take longer to detect than a typo. The cognitive shape of the work has shifted from "produce" to "review."

This is not, on balance, a worse mode of work. Many engineers prefer it. Multiple productivity studies of Copilot report speed gains on well-scoped tasks. But it is a different mode of work, and the people who learned to code in the editor-as-centre world are, in 2026, still adapting to the editor-as-viewer world. Many of the people who learn to code in 2026 may never encounter the previous mode.

What to watch next

The first is whether the chat panel finishes eating the terminal. Right now the terminal is still a place where engineers type. Cursor and Windsurf both have versions where the agent runs commands and the terminal output streams into the chat. If that pattern stabilises, the terminal becomes another viewer, and the chat becomes the only place humans type.

The second is whether the editor-as-viewer mode survives the next wave of agent maturity. If background agents can run for hours without a human looking at the chat, the chat itself stops being the primary interface. The engineer would set goals, walk away, and review the diff. The IDE in 2030 may look nothing like the IDE in 2026, just as the IDE in 2026 looks nothing like the IDE in 2018.

We are in the second of those transitions. The third feels near, though the timing is speculative. The screenshot from 2018, with the tree on the left and the file in the middle and the terminal at the bottom, may end up looking, to engineers in 2035, like a period photograph. It appears, in 2026, to be a minority configuration among developers using AI tools.