# How to see what your AI changed in a document

> Free and paid ways to see exactly what Claude, Codex or another AI changed in a file on your Mac, with or without git, instead of trusting its summary.

Source: https://oneclearreader.com/guides/see-what-ai-changed · Updated 28 September 2026 · One Clear Reader (Northlight Group Pty Ltd)

> [!answer] To see what your AI changed in a document, compare the file before and after instead of trusting the AI's summary. If the file is in a git repository, run `git diff` on it, or `/diff` inside Claude Code or Codex. If it isn't, keep a copy before the AI starts and compare the two in VS Code.

## Why not just trust the AI's summary?

You shouldn't just trust an AI's summary of its changes, because a summary is the AI's description of its work, and descriptions leave things out. "Tightened the intro" might also mean a deleted paragraph, a changed number, or a renamed heading three pages down.

A diff shows you the file itself. A **diff** is a before-and-after view that marks each added and removed line. It takes a minute to read, and it never forgets an edit.

> [!scribble] the summary is the trailer. the diff is the film.

## Which method should I use to see what an AI changed?

Pick a method for seeing what an AI changed by where the file lives. This table compares eight methods. Most people need only the first row that fits.

| Method | Works for | What you see | Cost |
|---|---|---|---|
| `git diff` | Files in a git repository | Added and removed lines, or changed words with `--word-diff` | Free |
| `/diff` in Claude Code | A Claude Code session in a git repository | Changed files, line counts and each diff | Included |
| `/diff` in Codex CLI | A Codex session in a git repository | The git diff, including new files | Included |
| Keep a copy, then compare | Any file, if you copy it first | A side-by-side diff in VS Code, or `git diff --no-index` in Terminal | Free |
| VS Code Timeline | Files you saved in VS Code | Earlier saves you can compare and restore | Free |
| macOS Versions | Apps that support it, like TextEdit | Earlier versions beside the current one. You spot the differences by eye | Free |
| Ask the AI for a change list | Anything | The AI's own list. A map, not proof | Free |
| One Clear Reader | Any Markdown or text file open while the AI edits | Changed sections marked on the formatted page, earlier versions to compare | Free, some parts Pro |

## How do I use git diff to see what an AI changed?

If the file is in a git repository, `git diff` shows exactly what the AI changed since your last commit. This is the most reliable check, because git compares the file against the last saved snapshot (a **commit**).

In Terminal, inside the project folder:

```bash
git diff -- plan.md
```

Lines starting with `-` were removed. Lines starting with `+` were added. For prose, where one word changes in a long line, this is easier to read:

```bash
git diff --word-diff -- plan.md
```

It shows removed words as `[-like this-]` and added words as `{+like this+}` ([git docs](https://git-scm.com/docs/git-diff)).

You don't have to leave your AI tool:

- **Claude Code:** type `/diff` to review "the edits Claude has made so far alongside anything else you haven't committed" ([Claude Code docs](https://code.claude.com/docs/en/interactive-mode#review-changes-with-%2Fdiff)).
- **Codex CLI:** `/diff` shows "the Git diff, including files Git isn't tracking yet" ([OpenAI docs](https://developers.openai.com/codex/cli/slash-commands)).

To undo a change rather than read it, Claude Code's `/rewind` restores files from the checkpoints it keeps of its own edits ([Claude Code docs](https://code.claude.com/docs/en/checkpointing)).

Commit before you ask the AI for a big rewrite. Then `git diff` shows exactly that rewrite and nothing older.

## What if the file the AI changed isn't in git?

If the file isn't in git, keep a copy before the AI starts, then compare the two. It sounds old-fashioned, and it works everywhere.

1. Duplicate the file before you ask for changes. In Finder, select it and press ⌘D ([Apple Support](https://support.apple.com/en-us/102650)). In Terminal: `cp plan.md plan-before.md`
2. Let the AI edit `plan.md`.
3. Compare the two files with one of these.

**In VS Code:** right-click `plan-before.md` in the Explorer and choose **Select for Compare**. Then right-click `plan.md` and choose **Compare with Selected** ([VS Code docs](https://code.visualstudio.com/docs/editing/codebasics#_compare-files)). You get the two side by side with changes highlighted.

**In VS Code, without a second file:** copy the whole file's text before the AI edits it. Afterwards, open the file and run **File: Compare Active File with Clipboard** from the Command Palette ([VS Code docs](https://code.visualstudio.com/docs/editing/codebasics#_compare-files)).

**In Terminal:** git can compare any two files on disk, even outside a repository ([git docs](https://git-scm.com/docs/git-diff)):

```bash
git diff --no-index --word-diff plan-before.md plan.md
```

## Does VS Code keep a file history I can compare?

Yes, VS Code keeps a local file history, for saves made in VS Code. Its Timeline view, at the bottom of the Explorer, lists local file history. From an entry you can compare with the current file or restore it ([VS Code docs](https://code.visualstudio.com/docs/editing/getting-started/userinterface#_timeline-view)).

The catch: VS Code's docs describe an entry being added each time you save in the editor. If Claude Code or Codex edits the file from a terminal, don't count on Timeline having caught the version before. Use git or a copy for those.

If the AI works inside VS Code, through an extension, check the extension's own change view first. It's usually the quickest.

## Can macOS show me an older version of a document?

Sometimes. macOS can show older versions of a document in apps that support it, like TextEdit. Many Mac apps save versions of a document as you work. Open the document and choose `File › Revert To › Browse All Versions` ([Apple Support](https://support.apple.com/guide/mac-help/view-and-restore-past-versions-of-documents-mh40710/mac)).

Apple says a version is saved automatically every hour, and also when you open, save, duplicate, lock, rename or revert a document. So if the file was open in a supporting app like TextEdit before the AI changed it, there may be a version from before.

Two limits. It only works in apps that support it, and code editors and most Markdown apps don't. And it shows versions side by side without marking what changed, so you compare by eye.

## Should I ask the AI for a list of its changes?

Yes, ask the AI for a list of its changes, but treat it as a map. Then check the map against the file. This prompt gets a useful list:

```text
List every change you made to plan.md.
For each one, quote the old text, then the new text.
Include deletions. Don't summarize.
```

Quotes let you search the file for each change in seconds. If the AI lists three changes and a diff shows five, you've learned something about the next summary it gives you.

## How do I see an AI's changes as they happen?

To see an AI's changes as they happen, use a reader that watches the file. One Clear Reader reloads the page when the AI saves, keeps your place, and tells you what moved. This table shows what each of its change features does and which plan it's in.

| Feature | What it does | Plan |
|---|---|---|
| Live reload | The badge says "Watching for changes", then "Updated just now" when the file changes | Free |
| Changed since the last refresh | "N sections new or changed since the last refresh", with **Next change**, **Show only changes** and **Dismiss** | Free |
| Changed since your last visit | Marks the blocks that changed since you last read the file. Remembers your last 80 files | Pro. Free shows the count and "See what changed" |
| Version history | Keeps a copy before each save and each outside change. **Compare** any version with the current one, or **Restore** it | Free sees the newest 3, Pro up to 25 |
| Check the changes | Before your own edit is saved (⌘S), shows the lines added and removed. "Save to file" or "Keep editing" | Free |

The first two are the "I just asked Claude to revise this" workflow. Keep the file open, ask for the change, and jump straight to the new parts instead of rereading the whole thing.

Version history is the safety net. Because it keeps a copy before outside changes too, an AI rewrite you don't like is one **Restore** away.

> [!note] Marked 3 also highlights changes between saves and scrolls to the first edit (checked 28 September 2026). If you already use it beside your editor, try that first.

For plans specifically, [reviewing a Claude Code plan before you approve it](/guides/review-claude-code-plan) uses the same markers to check a revision. If you'll be editing the file yourself afterwards, see [how to edit a .md file without breaking it](/guides/edit-md-without-breaking). And if you're weighing this against staying in VS Code, here's [One Clear Reader compared with VS Code](/compare/one-clear-reader-vs-vscode).

## Questions

### How do I see what Claude changed in my file?

To see what Claude changed in a file, type /diff in Claude Code if the file is in a git repository, or run git diff on the file. If it isn't, copy the file before asking for changes, then compare the two copies in VS Code.

### Can I see changes if I'm not using git?

Yes, you can see an AI's changes without git. Duplicate the file before the AI edits it, then compare the old and new copies with VS Code's Compare with Selected, or with git diff --no-index in Terminal.

### Does Claude Code keep old versions of my files?

Yes, Claude Code keeps old versions of files it edits, for undoing. Claude Code saves checkpoints of the files it edits, and /rewind can restore code to an earlier point. To view the changes rather than undo them, use /diff.

### Why doesn't Browse All Versions work on my .md file?

Browse All Versions only works in apps that support macOS versions, such as TextEdit. Most code editors and Markdown apps don't, so use git or a saved copy instead.

### What is a diff?

A diff is a before-and-after view of a file that marks every line or word that was added or removed. It shows the real changes, where a summary only describes them.