Using Claude Code in Zed with Terminal Threads

Jason Yang
23 May, 2026
Views —

If you use Claude Code often, you probably know this workflow already.

You open a terminal, run claude, ask it to change something, then switch back to your editor to check the diff. After that, you return to the terminal, send another instruction, and repeat the same cycle again.

It works, but after a while, moving between windows starts to feel a little annoying.

That is one reason tools like Cursor and Antigravity are attractive. They put the AI agent directly inside the editor, so the workflow feels smoother. But there is another side to that. These tools can feel heavy, especially on a laptop. When you already have a browser, Docker, local servers, and a few terminals open, another heavy Electron-based editor can be noticeable.

This is where Zed’s Terminal Threads feature becomes interesting.

It does not try to replace Claude Code.
It simply gives you a cleaner place to run it.

What is Zed?

Zed is a code editor built by the team behind Atom.

Unlike VS Code and Cursor, which are based on Electron, Zed is written in Rust and uses its own GPUI framework. In practice, this makes Zed feel fast and lightweight.

Of course, memory usage depends on the project, extensions, language servers, and how many terminal sessions you are running. But in general, Zed feels much lighter than the usual Electron-based editor setup.

Zed reached version 1.0 on April 29, 2026. Since then, the team has been moving quickly, especially around AI coding workflows.

One of the newer features is Terminal Threads.

What are Terminal Threads?

Terminal Threads let you run terminal sessions directly inside Zed’s Agent Panel.

That means you can open a terminal thread, run claude, codex, amp, or any other CLI-based agent, and keep everything next to your code.

In simple terms:

You still use Claude Code the same way you use it in a normal terminal.
The terminal just lives inside Zed’s sidebar.
You can check code changes without constantly switching windows.
You can create multiple terminal threads for different agents or tasks.

So Terminal Threads are not a new AI agent.
They are more like a better home for the CLI tools you already use.

Installing Zed on Kubuntu

I tested this on Kubuntu 25.10 with KDE Plasma and Wayland.

The easiest way to install Zed is to use the official install script.

curl -f https://zed.dev/install.sh | sh

The script installs Zed under ~/.local.

If your PATH is configured correctly, you can start Zed with:

zed

You can also install Zed through Flatpak or AUR, but the official script is simple and works well if you want automatic updates.

After installation, check the version:

zed --version

Terminal Threads are available from Zed 1.3.5.

Screenshot idea: show the zed --version output.

Opening a Project

Move into your project directory and open it with Zed.

cd ~/workspace/project
zed .

The Agent Panel is available from the right sidebar.

Keyboard shortcuts may be different depending on your OS, keymap, or personal settings. If the shortcut does not work, the safest way is to open the Command Palette and search for agent panel or threads sidebar.

Screenshot idea: show Zed with an empty Agent Panel on the right side.

Creating a Terminal Thread

In the Agent Panel, click the + button and choose Terminal.

This creates a new terminal thread inside the panel.

From there, you can run Claude Code just like you would in a normal terminal.

claude

If this is your first time running Claude Code, it may go through the authentication flow. After that, the experience is almost the same as using it in your regular terminal.

The nice part is that the session now stays next to your code.

Screenshot idea: show Claude Code running inside a Terminal Thread.

Running Multiple Agents

You can create another Terminal Thread and run a different CLI agent there.

For example:

codex

Now you can have Claude Code in one thread, Codex in another, and Zed’s own agent in the same sidebar.

This is useful if you like comparing tools or using different agents for different kinds of tasks.

For example, you might use:

Claude Code for refactoring
Codex CLI for quick code generation
Zed Agent for editor-integrated review

Each thread is tied to the current project and worktree, so the workflow stays organized by project.

Why I Like This Setup

The main benefit is simple: the workflow feels lighter.

With VS Code or Cursor, AI features are deeply integrated into the editor, which is powerful. But sometimes I do not need all of that. I just want to run the same Claude Code CLI I already use, while keeping it close to my code.

Terminal Threads are good for that.

1. Zed feels lightweight

Zed’s biggest strength is still speed.

It opens quickly, feels responsive, and does not add too much weight to the overall development environment. This matters when you already have several tools running at the same time.

For small and medium-sized coding tasks, this setup feels very comfortable.

2. Claude Code works the same way

This is probably the biggest reason I like Terminal Threads.

When I run claude inside a Terminal Thread, it is still the normal Claude Code CLI. Zed is not wrapping it in a different interface or changing how it behaves.

That means I can keep using my existing Claude Code setup:

~/.claude/
Skills
subagents
MCP servers
project-level CLAUDE.md
nested CLAUDE.md files
slash commands
custom commands
hooks and plugins

Nothing needs to be rebuilt just for Zed.

It is the same Claude Code workflow, just placed inside the editor.

3. Multiple CLI agents can live together

Terminal Threads are not limited to Claude Code.

If a tool runs in the terminal, you can usually run it in a Terminal Thread. That makes it easy to keep different AI agents in one sidebar without changing editors.

This is especially useful if you are still experimenting with different AI coding tools.

Terminal Threads vs ACP

Zed also supports external agents through ACP, which stands for Agent Client Protocol.

ACP is a protocol for connecting AI coding agents to editors in a more standardized way. A simple way to think about it is this:

LSP connects editors with language servers.
ACP tries to connect editors with AI coding agents.

They solve different problems.

ACP

ACP gives the editor deeper control over the AI workflow.

It can support richer editor features such as multi-buffer diffs, accept/reject controls, and better integration with Zed’s review UI.

If you want the AI agent to feel like a native part of the editor, ACP is probably the better path.

Terminal Threads

Terminal Threads are more direct.

They do not try to deeply integrate the agent into the editor UI. They just give you a terminal session inside the Agent Panel.

That means more freedom and fewer surprises.

If your priority is to keep your existing Claude Code CLI workflow exactly as it is, Terminal Threads are a better fit.

My simple rule is:

Use ACP when you want deeper editor integration.
Use Terminal Threads when you want the original CLI experience.
Use both if that fits your workflow.

It Does Not Replace Ghostty or Other Terminals

One thing is worth making clear.

Terminal Threads do not replace a real terminal like Ghostty, WezTerm, or Alacritty.

For long-running SSH sessions, tmux workflows, log monitoring, or heavy command-line work, I would still use a dedicated terminal.

Terminal Threads are better for smaller, editor-adjacent tasks.

For example:

asking Claude Code to refactor the current file
reviewing a diff and sending another instruction
running a quick CLI agent session
comparing Claude Code and Codex on the same project
keeping an AI session beside the code while editing

So I see Terminal Threads more like a small toolbox inside the editor, not a full replacement for my main terminal.

Final Thoughts

Zed’s Terminal Threads are not a flashy feature, but they solve a real workflow problem.

They let you keep using Claude Code the normal way, while reducing the friction of switching between your editor and terminal.

The value is simple:

Zed is lightweight.
Terminal Threads live inside the editor sidebar.
Claude Code still behaves like Claude Code.
Existing CLAUDE.md, MCP, Skills, and custom commands continue to work.
Multiple CLI agents can be managed in one place.

If you like Claude Code as a terminal tool but want a smoother editor workflow, Zed Terminal Threads are worth trying.

It is not a complicated idea.
But that is exactly why it works.