How to catch a redline that undoes a fix from last round

When a contract negotiation runs long, most of the review time on any given day goes into whatever just came back. You open the latest draft, work down the tracked changes, and clear each one. That's the natural way to spend the hour, and it's also an incomplete way to check the document. In a multi-round negotiation, the bigger risk tends to be older than the newest redline: a fix your team already won in round two, quietly gone by round four, with nothing in the file flagging it as new.

why a normal diff misses a reversion

A tracked-changes comparison shows you what's different between two specific files: the one you sent and the one that came back. That's useful, but it only catches a reversion if the base file used for the comparison is the right one. In a real negotiation, that base file gets muddled more often than anyone wants to admit. Someone on the other side merges edits from two reviewers and drops one. A draft goes to outside counsel who works from an older copy still sitting in their inbox. A clause you fixed in round two survives round three, then quietly reverts in round four because whoever touched the document that time started from the wrong version.

None of that shows up as a red flag in the redline you're handed. It just shows up as the original language, sitting there again, looking like it was always fine.

treat a closed decision as a standing rule, not a one-time fix

The habit that actually catches this has less to do with reading more carefully and more to do with changing what you check each draft against. Instead of comparing only to the last round, check the new draft against the full list of positions you've already settled, back to round one. If a clause you fixed in round two doesn't match that settled position anymore, it should get flagged, whether or not the file's own tracked changes show it as new.

The same idea shows up in how a numbered playbook works: a rule set with fallback positions and unacceptable deviations attached to each item, rather than a memory of what got negotiated last time. There's a longer look at how this plays out in how a playbook shapes what an AI review flags. Run the new draft against that same rule set every round, and something that no longer matches a position you already closed will surface again, whether or not it was technically "new" in that round's tracked changes.

the base file deserves as much suspicion as the redline

Before you trust any diff, it's worth confirming what it's actually comparing. A Florida law firm's breakdown of contract version control makes the point that a version is really two files, a clean draft and a redline, measured against the base the other side actually last saw, and the way to catch a mismatch is running the reject-all and accept-all checks against that base before you rely on what the redline claims to show. The same piece makes the point that a negotiation is a sequence of positions, and disputes get fought over that sequence, not just over the final wording. If the base is wrong, the diff built on top of it will tell you something false about what actually changed, and it will do it confidently.

where this still needs a person

An AI first pass can compare a returned draft against your playbook and flag terms that no longer match, the same way it flags anything else off your standard. The Association of Corporate Counsel's guide to contract lifecycle software describes the defensible version of this well: AI can read a counterparty's paper, compare it against a company standard, and flag missing or non-conforming clauses, compressing hours of first-pass review into minutes. What it can't do on its own is know which file the other side actually intended to send, or whether a reversion was an accident versus a second attempt at a point they'd already lost. That's a judgment call, and it depends on your team knowing which draft is genuinely the last one sent, not just the last one opened.

A goHeather review reads whatever you upload and scores it against the playbook you choose, through the AI contract review app, and that's a real check worth running on every round, not just the first one. It won't tell you on its own that the file the counterparty attached is stale. Confirming that the redline is measured against what you actually sent last, and not some earlier draft dredged back up, is still on your team.

The fix here doesn't require new software habits so much as a different question at the start of every round: not just "what changed," but "did anything we already fixed just come back." Build that question into how each draft gets checked, and a negotiation that runs six rounds stops being six separate reviews of six separate documents. It becomes one running check against a list that only grows.

This is legal information, not legal advice; consult a lawyer for legal advice.