How to See What Claude Code Changed in Your Project
To see what Claude Code changed, use its own tools while the session is open: run /diff in the terminal, or click the line counts (like +12 -1) in the desktop app's Changes card. Both show the work of the current session. For everything the agent did since you last looked, across sessions and cloud runs, you need the project's history: git on your computer, the commit list on GitHub, or an app that reads that history for you. This guide walks through each option, starting with the ones that need no setup, and is written for people who run a project with Claude Code but don't live in a code editor.
What Claude Code shows you on its own
Claude Code already has three ways to look at its work. All of them are good, and all of them are tied to a session.
/diffin the terminal. It opens a panel with what changed in your files: the uncommitted changes in the project and, per third-party write-ups like this one, Claude's edits turn by turn. It's read-only, so you can't break anything by looking.- The Changes panel in the desktop app. In the Code tab, Anthropic's desktop docs say to click the line counts in the Changes card, or Changes in the session's title bar. You get a file list on the left and each file's changes on the right. You can click a line, leave a comment, and Claude makes the change.
- The VS Code extension. If you happen to use VS Code, changed lines get colored markers in the margin, and the Source Control view lists modified files.
Red lines were removed, green lines were added. For a text project (notes, drafts, a CSV of deadlines) that's usually enough to answer "did it touch only what I asked?" A good guide on reading a diff without being a developer is eseospace's.
The gap: what happened while you were away
The built-in views answer "what did this session do?". They don't answer the question you have on Monday morning: what changed in my project since Friday, and who changed it — the agent or me?
That question spans several sessions, maybe a cloud session you started from your phone, and your own edits in between. Claude Code's session tools don't keep that kind of record. Its checkpoints, for example, only track edits made by Claude's file editing tools in the current session, and Anthropic's checkpointing docs say plainly that they are "not a replacement for version control."
The record you need is the project's version history. If your project is in git (many Claude Code projects are, often because the agent set it up), the history is already there. You just need a way to read it.
Reading the history with git or GitHub
If you're comfortable with a few commands, ask Claude itself or run them in the project folder:
git log --onelinelists versions (commits), newest first. Claude Code writes readable commit messages, so this list is often a decent summary on its own.git show <id>shows what one version changed.git diff HEAD~3compares the project now with three versions ago.
Who made a version? By default Claude Code adds a Co-Authored-By: Claude line to the commits it makes. Run git log without --oneline and you'll see it. If someone turned that setting off, the agent's commits look like yours.
If the project is on GitHub, open the repository, click the commit count above the file list, and click any commit to see its changes. In a commit, red and green lines work the same way as above, and pictures get a side-by-side or swipe view.
Cloud sessions. When you run Claude Code on the web (claude.ai/code), the agent works on a GitHub repository and usually pushes to a separate branch whose name starts with claude/. Its work isn't in your main version until someone merges it, so it won't show up in the main commit list. On GitHub, open the branch list or the pull request to see what it proposes.
GitHub Desktop is a free app that shows the same history in a window, with a diff for each commit. It's a git client, though: commit, push, pull, branch and revert are the words on its buttons.
A project view without git words
This is the part where we talk about our own product. We make X-Filer, a desktop app for Windows and macOS, and its agent projects mode was built for exactly this question. It reads the project's history and shows it in plain words:
- Since your last visit. The project overview says in one line how many versions are new since you last looked and how many of them came from the agent, and marks the new cards in the feed.
- A feed by day. Each version shows who made it — Agent or You — when, the first line of its message, and which files are new, changed or deleted. Unsaved changes on your computer get their own card on top.
- What changed. Text and Markdown are compared line by line with unchanged parts folded away. Pictures are shown before and after, side by side.
- Cloud agent proposals. For a GitHub project, X-Filer lists what the cloud agent proposes — its versions that the main version doesn't have yet — with a link to compare them on GitHub.
- What your agent knows. CLAUDE.md, skills, helpers and commands appear as a readable list instead of a
.claudefolder.
From any change you can Restore as it was (one file) or Revert version (a whole version). We cover undoing in a separate guide: how to undo Claude Code changes.
What it needs, honestly:
- A local project needs git installed to have a history. You never see git terms; X-Filer tells you if git is missing. Without git, you can still read and edit every file, but there's no history to show.
- A GitHub project needs only a GitHub sign-in.
- A project in a Google Drive or Yandex Disk sync folder works on macOS for now. X-Filer then lists the files changed since your last visit, without an author (the drive client saves the agent's edits under your name). With Google Drive connected in X-Filer, it compares a file with its earlier revision; Yandex Disk offers no file history to other apps, so there's nothing to compare against.
- Agent vs. you is told apart only by Claude Code's commit signature. Other agents' projects open too, but their versions show up as yours.
- No iPad app yet. One is planned; today X-Filer runs on Windows and macOS.
X-Filer has no server of its own: it reads the project from your disk, from GitHub with your sign-in, or from your drive. More on how it works on the agent projects page.
Which way fits you
| Covers | Shows agent vs. you | Needs | |
|---|---|---|---|
/diff / Changes panel |
the current session | — (it's all the session) | Claude Code open |
| VS Code extension | uncommitted changes, session | no | VS Code |
git log / git show |
full history | yes, by the commit line | git commands |
| GitHub website | full history, cloud branches | yes, by the commit line | project on GitHub |
| GitHub Desktop | full history | in the commit details | git vocabulary |
| X-Filer | since your last visit, full history, cloud proposals | yes, Agent / You | git installed, or GitHub sign-in; macOS for drive folders |
- You check right after each session: the Changes panel or
/diffis all you need. - You come back after a few days and want the story: read the history, on GitHub or with
git log. - You want that story without terminals and git words: try X-Filer on the project.
FAQ
Can I see what Claude Code changed without git?
Inside a session, yes: /diff and the desktop Changes panel work as you go. Across sessions, you need some kind of history. Without git, the closest thing is a cloud drive's own version history (Google Drive keeps earlier versions of a file) or your system backups.
How do I know which changes Claude made and which I made?
Look for the Co-Authored-By: Claude line that Claude Code adds to its commits by default. Edits you make by hand and commits without that line are yours. In X-Filer, the feed marks each version Agent or You using that line.
Where do I see what a Claude Code cloud session did?
On GitHub. A cloud session works on a branch (usually starting with claude/) and may open a pull request. Its changes appear in your main version only after they're merged.
Bottom line
Claude Code shows its work well while a session is running. For "what happened since I last looked", the answer lives in the project's history, and you can read it with git, on GitHub, or in an app that translates it into plain words. If that last one sounds right, see how X-Filer's agent projects work.