AI has fundamentally changed how we write code, but our IDEs are still stuck in the past.
Most editors still treat the file tab as the primary unit of work. That assumption held up when humans wrote code line-by-line. It completely breaks down when an AI agent is producing, executing, and revising code across an entire workspace at once.
The bottleneck isn’t generation speed anymore. It’s continuity.
The Real Bottleneck
AI can spit out a 5-file refactor in seconds. That’s the easy part. The friction happens after the code is generated:
- The Context Tax: Trying to remember exactly what you told the agent three hours ago.
- The Review Loop: Jumping between a terminal, a diff view, and three different files to see if the change actually worked.
- The “Resume” Problem: Opening your laptop on a Tuesday and trying to reconstruct the “state” of an unfinished AI task from Monday.
These aren’t typing problems; they are coordination problems. And they don’t fit inside a tab.
Tabs Are the Wrong Primitive
Tabs assume work is organized around locations (files). AI work is organized around intent (tasks).
When you tell an agent to “migrate this auth logic,” that work isn’t a file. It’s a Session. A session is a living container that holds:
- The Goal: The original intent.
- The Execution: The specific CLI commands the AI ran.
- The Delta: The exact changes made across the codebase.
- The State: Whether it’s tested, reviewed, or needs more work.
Tabs are for static viewing. Sessions are for ongoing execution.
Why Legacy IDEs Feel Fragmented
Most modern IDEs “bolt” AI onto a file-centric UI. You end up with:
- A chat window in one corner.
- A terminal in another.
- A “floating” diff that disappears the moment you click away.
Every time you switch projects or tasks, you have to manually reconstruct that state. As a developer, that cognitive load is a productivity killer. You spend more time “managing the AI” than actually shipping features.
Sessions Scale; Tabs Rot
Sessions allow for things a tab-based workflow can’t handle:
- Asynchronous Work: Let an agent run a complex migration in the background while you work on something else.
- Deep Persistence: Close the IDE, go to sleep, and wake up with the exact execution context ready to be resumed.
- Parallel Intent: Running three different experiments in three different sessions without them bleeding into each other.
Once you stop thinking in “files” and start thinking in “sessions,” the traditional IDE layout starts to feel like a straightjacket.
Why I Built RexIDE
I didn’t build RexIDE because I wanted to compete with VS Code. I built it because I was tired of losing my train of thought.
I needed a tool that treated CLI agents and long-lived sessions as the first-class citizens. I wanted an IDE where execution and continuity were the “center of gravity,” not just an afterthought in a sidebar.
The Shift
As AI models get smarter, the limiting factor won’t be how many tokens they can generate. It will be how easily a human can review, validate, and resume the work the AI started.
Sessions aren’t just a UI choice. They are a different mental model for how software gets built in 2026.
If this approach matches how you work, you can explore the execution-first workflow at rex-ide.com.