How to view Claude Code changes in real time (and know what the AI is doing)

Three ways to see what has changed and know what the AI is doing

Quick summary of the system:

• The live diff per terminal tells you: this is exactly what Claude has changed in this session, in these files
• The Git diff tells you: this is everything that has changed in the project compared to Git, whether from Claude or manual changes
• Dynamic titles tell you: this terminal is currently working on X task, module or part of the system, plus you can see the title history

All three together answer: what is the AI doing right now, what has changed in this session, and what has changed in the project overall.

These tools really shine when you're running several Claude Code sessions in parallel. To learn how to set them up, see this guide: How to Use Multiple Claude Code Terminals (Without Losing Your Head).

Live diff per terminal: see what Claude changes in that session

Imagine you have a Claude Code terminal working on something specific, for example "refactoring the notifications module".

As Claude writes files, CodeAgentSwarm automatically tracks everything it does:

• Every time it uses Write or Edit on a file
• Every time it makes changes via Bash (sed, echo, redirections...)

Those changes are stored in memory, associated with the terminal where it is working and the file it has touched.

Each terminal has its own isolated session, so if you have four terminals at once, each one accumulates its changes separately. This is key if you want to see Claude Code changes in real time per session without mixing contexts.

In the UI you see it with a button in the terminal bar with a change counter, and a modal specific to that session.

What you see inside the Session file changes modal

Inside the Session file changes modal you have:

• A side panel with the list of files Claude has touched in that session
• A diff per file with added and removed lines
• Collapsed sections so you don't have to go through the whole file if it's very large
• A Clear session button to reset when you start a new task

The important thing here: you only see what that specific terminal has changed, it doesn't mix changes from other terminals, and you don't depend on the project having Git configured.

It's a magnifying glass placed on top of what that Claude Code instance is doing. If you're wondering how to see what Claude Code has changed before applying anything or before asking it more things, this is the place.

Git diff: see changes at project level

The other diff viewer in CodeAgentSwarm is the classic one you expect when working with Git repos.

It compares the current state of your files against:

• The staging area, to see changes you have prepared for commit
• The working tree, to see changes you haven't added to staging yet

And it shows them in a diff modal with two ways to view it:

• Column view, original on the left and modified on the right
• Unified view, all in a single column with added and removed lines

From the interface you usually get to this diff from the project's Git panel or from Diff buttons associated with modified files.

This diff doesn't distinguish whether the changes come from Claude, from you, or from an external script. It's the global picture of the project against the repository, and it's the answer to the classic question before committing: what exactly am I going to push.

To resume past conversations and avoid re-explaining your code decisions, see this guide: How to Use Claude Code History to Recover Context and Save Time.

How to know what the AI is doing in each terminal (dynamic titles and history)

So far we've talked about what has changed. But there's another equally important part: knowing what the AI is doing right now in each terminal.

That's where CodeAgentSwarm's dynamic titles come in.

Claude, while working, can update the terminal title with what it's doing. Something like:

• Refactor notifications service
• Implement checkout flow
• Write tests for payment retries
• Clean up old feature flags

That gives you instant context: you open the terminals view, read the titles, and you know right away what each one is tackling, without having to read 200 lines of logs.

The title history

In addition to that, CodeAgentSwarm saves a history of titles per terminal. If you want to see what the AI has been doing over time in that terminal, you can review the list of previous titles and reconstruct quite clearly the timeline of tasks it has been working on.

Dynamic titles:

• Reflect the task or objective of that terminal
• Help you quickly identify: this one is payments, this one is notifications, this one is tests
• And with the title history they allow you to see how work has evolved in that terminal

They combine very well with diffs: you see the current title or the title history to understand what Claude was doing, you open the session diff to see what has changed in that stage, and you use the Git diff to see how it all fits in the project.

If you want to receive notifications when a session finishes or needs input, see this guide: How to Use CodeAgentSwarm Notifications to Stay in Focus with Claude Code.

How this fits when working with multiple terminals at once

Where all this is most noticeable is when you do what CodeAgentSwarm is designed for, which is working with multiple Claude Code terminals in parallel.

Example with three terminals:

• Terminal 1 - dynamic title: Refactor notifications service - session diff: changes only to the notifications module
• Terminal 2 - dynamic title: Implement profile page UI - session diff: changes to frontend components
• Terminal 3 - dynamic title: Add integration tests for X - session diff: only tests

With that combination: dynamic titles tell you what the AI is doing in each place, the live diff per terminal tells you what has changed in that specific session, and the Git diff gives you the complete picture of the project before committing anything.

You stop having the feeling of "I have three AIs doing things and I don't really know what's happening in the repo".

When to use each one

Simple way to see it.

Use the live diff per terminal when

• You want to see what Claude has changed in that specific session
• You're testing an idea and want to review its changes before continuing
• You're in a project without Git but want control over AI changes
• You want to see Claude Code changes in real time per terminal

Use the Git diff when

• You're preparing a commit
• You want to review all project changes, whether from Claude or from you
• You want to see the before and after at repository level

Rely on dynamic titles and their history when

• You have several terminals at once and want to quickly know what each one is doing
• You want to go back to a specific terminal that you remember by the task, not by the number
• You want to reconstruct what the AI has been doing over time in that terminal
• You want the workspace to be readable at a glance without opening diffs all the time

Advantages and limitations of each approach

Live diff per terminal

Advantages:

• Doesn't depend on Git
• Shows you exactly what Claude has done in that session
• Isolated per terminal, ideal when working in parallel
• You can reset it when you change tasks

Limitations:

• Only sees changes that Claude Code makes, not your manual edits
• Data lives in memory, if you close the app it's lost
• On very large files it might take a bit to calculate the diff

Git diff

Advantages:

• It's the classic Git diff, integrated in the workspace
• Shows you the picture ready for commit or changes in the working tree
• Includes both Claude's changes and yours

Limitations:

• Requires the project to be a Git repository
• Doesn't tell you which part came from Claude and which from you
• Not organized by terminal session