I got into the Delta whitelist and spent some time using it for work and not-so-work-related stuff. And I really liked it — this is exactly what I was missing. It’s not some ugly terminal thing written in JS and React, nor a janky stripped-down extension for Zed or VS Code. It’s a native, fast app that does a lot right out of the box.

What does it have that Claude Code, Codex, and OpenCode don’t?

First of all, really damn good code review

Before this, I used revdiff by Umputun, but objectively speaking, it’s a pretty hacky workaround. Opening some TUI program through tmux and terminal overlays, only for it to write something like line_number: comment when you exit — eh, not exactly great.

Here, you just walk through the code, leave comments, and then send them to the agent in one action. It’s very similar to how we do reviews in GitLab or GitHub. Really damn nice.

Second, worktree-based workflow

The folks at Atom — the same people building Zed and Delta — have been pushing Git worktrees for a long time, going all the way back to the Atom days.

I like this approach too. Especially in the age of agentic coding, I don’t really want to let an agent loose directly in my working tree. It’s much more convenient to create a worktree from the current state of the project and let the agent have fun there. After the review, the changes can be moved into the main branch.

That’s exactly what Delta does: each thread gets its own worktree, and all the work happens there. It’s both safer and more convenient, especially when multiple agents are working in parallel.

Third, a rather niche use case, but...

Collaborative work.

I can share a session and work on a task together with a colleague in real time. I really like this feature in Zed itself. At work, I occasionally use it to look at code together with colleagues, and it’s much more convenient than sharing your screen during a call and trying to show someone what you’re doing.

And once coding started turning into chasing AI agents around, it became logical to share not the code itself, but the session: the plans, the reasoning, the same code, and now also the diffs produced by the agent.

Not many people need this, but personally, I consider it one of the best features in both Zed and Delta.

Fourth, NATIVENESS

YES. GOD. YES.

I am so damn tired of this entire zoo of Electron, JS, and TS. Why? What for?

(Ironically, the people who created Zed also created Electron for Atom back in the day, and now they’re trying to do everything natively. Making up for their sins 100%.)

Why, for example, would you write Bitwarden in TypeScript? Both the desktop app and the CLI. Why would you write Claude Code in TypeScript? And React on top of that?

Electron has generally become a genuine plague of modern desktop software, so the fact that Delta is fast and native is a huge plus.

What is it actually missing?

First and foremost, custom providers.

I really want to connect a work model using our own tokens (mostly so the security people don’t come after me) and work through it. Maybe this isn’t available yet simply because Delta is still in closed beta. But I didn’t see a single word about custom providers on the roadmap.

Then, of course, Git integration.

Right now, they suggest moving changes over using stash or checking out commits from the worktree in your terminal outside of Delta. I’m not really against that, but I’d like to have a slightly more convenient way of doing it. Fortunately, this is already on the roadmap, so they’ll probably improve it.

And finally, switching agents.

I’d like to first build a plan with a read-only agent and then hand it over to another agent to actually do the work. That’s not possible yet, but we’ll see how the product evolves.

At some point while working, I caught myself thinking that I don’t really perceive Delta as yet another tool for working with AI — or even as an “agentic IDE.”

With the arrival of full-fledged agents in our workflow, the development process itself has changed. Previously, a code editor was primarily where you wrote code yourself. Now, you open it mostly to read the code the agent wrote — and even that happens pretty rarely, because the diffs in Claude Code / Codex are often enough.

In Delta, all of this is there. You can read the entire project, manually edit the code if you need to, and leave comments for the robot even outside of diffs.

That’s exactly why Delta feels less like yet another little chat window bolted onto an editor and more like an attempt to build the next generation of code editor.

Here, the agent isn’t an add-on to the familiar workflow anymore. It becomes one of the core entities of the system, alongside the code (or perhaps even above it), Git, and the developer.