Mimic vscode's git diff staged/unstaged UI

[alshdavid]

Body

What are you proposing?

Mimic vscode's stages / unstaged separation

Why does this matter?

I use this constantly when "guide coding" with agents.

That is; using a flash model in a fast development loop consisting of;

• prompt for small change
• review
• prompt for small change
• review
• repeat

What becomes easier or possible?

It allows me to "git add" the changes up until now. Prompt the agent to do some work, then observe the diff compared to the staged files and either accept, modify or veto/re-prompt.

As you know, with agentic workflows, reviewing is the most important piece and a UI that makes it easier to rapidly and ergonomically review the output is highly valuable.

With the Zed UI, I need to commit changes between prompts then squash them before pushing - which is annoying.

Screenshots, mockups, workflows, or examples from other tools.

I can see;

• The diff for the added setting.json vs HEAD
• The diff for the uncommitted settings.json vs the committed one.

In Zed:

With Zed, while it's visible that there are uncommitted changes to settings.json, it doesn't stick out making it less obvious that I need to review those changes.

Also, vscode has a nice little icon highlight for agent-generated diffs that need review, which I really love

Note: keep is "keep the AI generated diff", which is different to "stage"

[alshdavid]

Sorry, I know I am bumping my own post. I really really want to use Zed but this is a deal breaker. It's literally the only reason I am not using it.

#64531

Rewritten

This is the only thing that actively prevents me from using Zed as my daily driver. Everything else is a QoL or minor feature that I can wait for.

For me, the most important aspect of agentic workflows is reviewing the agent edits. In-editor workflows are great for tight "prompt, review, prompt, review" loops.

VSCode

VSCode will split the git diffs into;

• Staged
  • Compared against current branch
• Unstaged
  • Compared against staged

This unlocks an agentic workflow where I accumulate agent edits by incrementally staging agent edits each turn. I am able to quickly prompt-review partial updates as unstaged diffs, adding or veto/retrying the turn.

The final commit I generate represents a complete idea which aggregates several individually reviewed turns.

Screencast_20260921_084829.mp4

I love this workflow as I can write high quality code with AI, distribute the review burden into smaller digestible blocks which empirically outperforms my peers (at least for now, haha) who use completely headless approaches to agentic coding.

Zed

The git diff view in Zed combines staged and unstaged edits into a single diff against the current branch.

Screencast_20260921_085750.mp4

Why this is a deal breaker

Blending agent edits into a single giant diff against the current branch means I don't know what edits were made in the last turn. This makes it essentially impractical to accumulate edits incrementally.

I can get around this by committing the last turn and eventually squashing the turn commits into a single idea - but that extra friction is annoying enough that I never do. It also makes it much more annoying to revert changes if you get 5 turns deep and realise you have to scrap the approach.

It also doesn't give you an overview of the complete feature vs the current branch.

You can create a branch every time you want to start working with the agent and commit the diffs - but I use the agent constantly and creating a branch every time is even more friction.