Open the two Word documents to see a complete first-pass review. In the incoming pilot agreement, Example Buyer has three business days to review a report. The review copy proposes ten, cites the exercise rule in a comment, and leaves a renewal decision open for counsel. Both files contain the same delivery table.
Inspect the fictional example
Download the incoming agreement and the review copy, or use the ZIP to get the instructions and verifier as well. The example is in English across all six editions of this guide. You can inspect it locally without a Claude account or customer documents.
Keep the incoming file intact. Open the review copy in Word and display all markup and comments. In clause 2, find the deletion of “three” and insertion of “ten”. The adjoining comment cites REVIEW-01 and asks counsel to check the period against the pilot schedule.
Read clause 3. The renewal wording remains in place, including its five-day notice period. The second comment, HOLD-01, asks for a decision because the exercise playbook has no renewal position. Clause 1 and the delivery table have no proposed edits.
Make two disposable copies of the review file. Reject both revisions in one and confirm the sentence matches the original. Accept both in the other and confirm only the review period changes. Inspect comments separately. Hiding markup does not resolve a revision. Microsoft’s Word instructions
Verify what the file preserves
From the extracted ZIP, run python3 verify_sample.py. Python 3 reads the two sample files locally. A passing result begins with PASS: one replacement, two anchored comments. The script checks the native insertion and deletion, comment anchors and references, and the document body after projecting each decision. It also checks the table, styles and unrelated package content against the original.
Read examples/review-notes.md alongside the documents. Its three entries separate an unchanged clause, a proposed substitution and an unresolved decision. The sample documents were assembled offline, rendered for layout and checked structurally. This verifies the shipped pair. It does not establish that Claude can preserve arbitrary documents or that these terms are appropriate for a real agreement.
Use the instructions on an approved matter
Choose this workflow when counsel has approved a playbook for the agreement type and a named reviewer can examine every proposed edit. If a live draft contains unresolved revisions, conflicting exhibits, missing definitions or an unfamiliar clause, preserve the original and bring those issues to the reviewer before proposing wording.
SKILL.md describes the review steps. The three files in references/ supply the fictional rule, replacement text and escalation decision. Replace them with your organization’s approved rules, exact fallback language, version, owner and escalation criteria before working on an actual NDA or MSA. The exercise’s ten-day period is not a default position for other agreements. The contract review SOP can help define the handoff.
Confirm that the matter owner permits the chosen account and document handling. The Skill provides written instructions. It cannot enforce account policy, verify privilege, connect to a CLM or transmit a draft. A reviewer using Claude needs an approved editor that can preserve existing Word features. If only plain text is available, return a clause-by-clause note and have the reviewer enter proposals in Word. Preserve previous reviewers’ markup, cross-references, exhibits, comments and definitions on a separate version.
Decide whether to adopt it
Run a pilot on material approved for evaluation. Record missed issues, incorrect substitutions, unsupported proposals, review minutes and any damaged document features. Include editor or model charges and counsel time when comparing with the existing process. No live contract, vendor cost, time saving or legal outcome was measured in this example.
Counsel decides whether each proposal is acceptable and resolves every hold. The matter owner controls release. Before sharing a document, review the final version, comments, metadata and recipients through the organization’s normal process.
# Inspect the fictional Word redline
This bundle demonstrates a first-pass review on a one-page English pilot agreement. No customer data, account or network access is required for the example.
1. Open `examples/incoming.docx`. Clause 2 gives the buyer three business days. Keep this original unchanged.
2. Open `examples/review-copy.docx`. In Word, choose Review and display all markup and comments. Find the deleted “three”, inserted “ten” and the REVIEW-01 comment. Find the second comment, HOLD-01, attached to the original renewal clause.
3. Save two disposable copies. Reject both revisions in one copy and confirm clause 2 reads “three business days”. Accept both in the other and confirm it reads “ten business days”. Check clause 1, its table and the full renewal clause against the original. Comments are a separate review item.
4. With Python 3 installed, run `python3 verify_sample.py` from the extracted folder. It compares the fixed pair using the standard library, without modifying either document. Success begins with `PASS: one replacement, two anchored comments`. A failed check exits with an error.
`examples/review-notes.md` records each decision. `SKILL.md` and the three references guide a reviewer adapting this pattern with an approved editor and playbook. The verifier is limited to these fixture files. The example was assembled offline and inspected structurally and visually. It was not generated by a live Claude run or tested on client agreements.
[Microsoft instructions for accepting or rejecting revisions](https://support.microsoft.com/en-us/word/accept-or-reject-tracked-changes-in-word)
---
name: contract-redline
description: Prepare an internal, clause-level review against a supplied playbook. Use the fictional Word example to verify a tracked proposal and a decision held for counsel.
---
# Contract redline review
## Inputs and responsibility
Ask for the original draft, the applicable version of a counsel-approved playbook, the selected fallback text and the named reviewer. Record the agreement version and review perspective. Work on a copy. The three files in `references/` contain training positions for a fictional pilot. Replace them before considering a real agreement.
Have the matter owner confirm that the account, client, permissions, retention and document handling are approved for this specific material before using an assistant. These instructions cannot inspect account settings, enforce confidentiality or authorize disclosure. Keep the original, revisions and review notes within the approved location.
## Decide what goes in the review copy
1. Inventory the source. Record headings, clause numbers, cross-references, definitions, tables, exhibits, existing comments and revisions. If the available document editor cannot preserve them, stop at a text-only review note. Do not label that note a tracked DOCX.
2. Map each clause to an approved rule ID and cite the exact source words. Keep wording when the rule accepts it. When the rule permits a substitution, use the approved text and identify the smallest edit.
3. Hold the original text for counsel when the rule is absent, conflicting, expired or unclear, an exhibit is missing, or defined terms and dependencies would change. Identify the decision needed. Do not generate a fallback for an uncovered clause.
4. With an approved Word-compatible editor, save a separate review copy. Add real tracked revisions and an anchored comment with the rule and rationale. An assistant without that editor delivers the review notes for manual entry. No connector, universal DOCX writer, automatic policy enforcement or sending action is included.
5. Reconcile the review copy against the original. On separate disposable copies, reject all revisions and compare with the source, then accept them and confirm each planned substitution. Inspect comments, tables, formatting, definitions and exhibits. Preserve any existing revisions separately from the new proposal.
## Fixture and expected findings
Open `examples/incoming.docx` and `examples/review-copy.docx`. The review period changes from “three” to “ten” with a native deletion and insertion. One comment cites `REVIEW-01`. Renewal receives the `HOLD-01` comment and retains its wording. The report table and clause one remain intact. See `examples/review-notes.md` for all three decisions.
Run `python3 verify_sample.py` from the extracted bundle. The script reads only the provided pair. It checks accept/reject projections, comment anchors and preservation of the other package content. It does not generate a redline for an arbitrary agreement. The sample requires no model, account or network.
## Handoff
For each clause, include the source quotation, rule/version, proposed change or hold reason and named decision owner. Keep open questions and multiple possible positions visible. Counsel checks the legal and commercial implications, existing markup and negotiation history. Obtain the required approvals before accepting changes or sharing any copy, including its comments and metadata.
"""Check the two shipped fictional DOCX files using Python's standard library."""
from copy import deepcopy
from pathlib import Path
from xml.etree import ElementTree as ET
from zipfile import ZipFile
EXAMPLES = Path(__file__).resolve().parent / "examples"
W = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}"
REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments"
TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"
REVIEW = "Example Buyer will review each report within three business days of receipt."
RENEWAL = "The pilot renews for another two weeks unless either party gives notice five days before expiry."
def check(condition, message):
if not condition:
raise ValueError(message)
def parts(filename):
with ZipFile(EXAMPLES / filename) as archive:
check(len(archive.namelist()) == len(set(archive.namelist())), "Duplicate package part")
return {name: archive.read(name) for name in archive.namelist()}
def xml_bytes(element):
return ET.tostring(element, encoding="utf-8")
def project(body, decision):
"""Remove comments and resolve this sample's run-level revisions in memory."""
result = deepcopy(body)
for paragraph in result.iter(W + "p"):
children = []
for node in paragraph:
if node.tag in {W + "commentRangeStart", W + "commentRangeEnd"}:
continue
if node.tag == W + "r" and node.find(W + "commentReference") is not None:
continue
if node.tag in {W + "ins", W + "del"}:
keep = node.tag == (W + "ins" if decision == "accept" else W + "del")
if keep:
for deleted in node.iter(W + "delText"):
deleted.tag = W + "t"
children.extend(list(node))
else:
children.append(node)
paragraph[:] = children
return result
def main():
original, reviewed = parts("incoming.docx"), parts("review-copy.docx")
comments_path = "word/comments.xml"
check(set(reviewed) == set(original) | {comments_path}, "Unexpected package parts")
changed = {name for name in original if original[name] != reviewed[name]}
check(changed == {"word/document.xml", "word/settings.xml", "word/_rels/document.xml.rels",
"[Content_Types].xml"}, "Unrelated package content changed")
before = ET.fromstring(original["word/document.xml"])
after = ET.fromstring(reviewed["word/document.xml"])
deletions = list(after.iter(W + "del"))
insertions = list(after.iter(W + "ins"))
check(len(deletions) == len(insertions) == 1, "Expected one deletion and one insertion")
check([t.text for t in deletions[0].iter(W + "delText")] == ["three"], "Wrong deletion")
check([t.text for t in insertions[0].iter(W + "t")] == ["ten"], "Wrong insertion")
ids = [node.get(W + "id") for node in deletions + insertions]
check(None not in ids and len(set(ids)) == 2, "Revision IDs must be distinct")
settings = ET.fromstring(reviewed["word/settings.xml"])
check(settings.find(W + "trackRevisions") is not None, "Tracking is not enabled")
comments = ET.fromstring(reviewed[comments_path])
check(len(comments) == 2, "Expected two comment bodies")
rels = ET.fromstring(reviewed["word/_rels/document.xml.rels"])
check(any(r.get("Type") == REL and r.get("Target") == "comments.xml" for r in rels),
"Missing comments relationship")
types = ET.fromstring(reviewed["[Content_Types].xml"])
check(any(t.get("PartName") == "/word/comments.xml" and t.get("ContentType") == TYPE for t in types),
"Missing comments content type")
for path, tree, addition in [
("word/settings.xml", settings, settings.find(W + "trackRevisions")),
("word/_rels/document.xml.rels", rels, next(r for r in rels if r.get("Type") == REL)),
("[Content_Types].xml", types, next(t for t in types if t.get("PartName") == "/word/comments.xml")),
]:
tree.remove(addition)
check(xml_bytes(tree) == xml_bytes(ET.fromstring(original[path])), "Unexpected change in " + path)
for cid, rule, expected in [("0", "REVIEW-01", "threeten"), ("1", "HOLD-01", RENEWAL)]:
bodies = [c for c in comments.findall(W + "comment") if c.get(W + "id") == cid]
check(len(bodies) == 1 and rule in "".join(bodies[0].itertext()), "Missing comment " + rule)
anchors = {}
for kind in ("commentRangeStart", "commentRangeEnd", "commentReference"):
matches = [n for n in after.iter(W + kind) if n.get(W + "id") == cid]
check(len(matches) == 1, "Invalid " + kind + " for " + rule)
anchors[kind] = matches[0]
paragraph = next(p for p in after.iter(W + "p") if anchors["commentRangeStart"] in p)
nodes = list(paragraph)
start, end = nodes.index(anchors["commentRangeStart"]), nodes.index(anchors["commentRangeEnd"])
check(start < end and anchors["commentReference"] in nodes[end + 1], "Misplaced comment reference")
check("".join(text for n in nodes[start + 1:end] for text in n.itertext()) == expected,
"Comment attached to unexpected text")
check(xml_bytes(project(after, "reject")) == xml_bytes(before), "Reject changed the original document body")
accepted = deepcopy(before)
text_nodes = [t for t in accepted.iter(W + "t") if t.text == "three"]
check(len(text_nodes) == 1, "Missing unique review-period token")
paragraphs = ["".join(p.itertext()) for p in before.iter(W + "p")]
check(REVIEW in paragraphs and RENEWAL in paragraphs, "Missing fixture clause")
text_nodes[0].text = "ten"
check(xml_bytes(project(after, "accept")) == xml_bytes(accepted), "Accept changed unrelated content")
print("PASS: one replacement, two anchored comments, accept/reject document bodies and preserved package parts.")
if __name__ == "__main__":
main()
# Fictional pilot deviation notes
Source is `incoming.docx`. Output is the separate `review-copy.docx`. The three rules use the exercise version dated 2026-11-02. The review perspective is Example Buyer. All decisions remain with the reviewer.
| Location | Source and decision | Evidence in the review copy |
|---|---|---|
| 1 Pilot report | REPORT-01. Keep the weekly inventory report and delivery table | No revision or comment |
| 2 Review period | REVIEW-01. Replace “three” with “ten” in the review period, leaving “business days of receipt” in place | One deletion, one insertion and one comment at the replacement |
| 3 Renewal | HOLD-01. The playbook lacks a position on automatic renewal and the five-day notice period | No revision. One comment anchored to the unchanged sentence asks counsel to decide |
The exercise leaves the renewal decision open. Counsel should also consider whether the proposed ten-business-day review period works with a two-week pilot. The redline has not been approved for negotiation or execution.
# Fictional pilot review playbook
Exercise version 2026-11-02. Perspective is Example Buyer. These positions apply only to the English pilot excerpt in the sample. The example supplies no firm's approved positions or jurisdictional conclusions.
| Rule | Match in the sample | Action |
|---|---|---|
| REPORT-01 | Clause 1 describes the inventory report, PDF format and weekly delivery | Leave the clause and table intact |
| REVIEW-01 | Clause 2 gives Example Buyer three business days to review each report | Propose the time period in the fallback file and attach a comment |
| HOLD-01 | Clause 3 automatically renews the pilot and sets a notice period | Preserve its words and request a decision from counsel |
For your own version, identify the client or matter, review perspective, agreement types, owner, approval date, version, exact allowed language and mandatory escalations. Have counsel approve the replacement before working on live material. A similar title alone does not establish a rule match.
# Fictional fallback text
Exercise version 2026-11-02. The sample uses one substitution under REVIEW-01. It demonstrates the mechanics of a tracked change. Ten business days is an invented exercise position.
Original clause 2 sentence:
> Example Buyer will review each report within three business days of receipt.
Proposed sentence:
> Example Buyer will review each report within ten business days of receipt.
Delete only “three” and insert “ten”. Preserve the surrounding sentence and its formatting. Attach the REVIEW-01 comment to the replacement. Ask counsel to check the period against the two-week pilot schedule.
REPORT-01 has no substitution. HOLD-01 has no fallback text. A real fallback library needs an approval record, scope and stable rule ID for each entry.
# Review holds
Exercise version 2026-11-02. Clause 3 has a renewal and notice mechanism. The fictional playbook supplies no accepted renewal position. Leave the whole clause unchanged and attach a HOLD-01 comment asking counsel whether to keep or revise it.
For real matters, have counsel define the escalation rules for the specific agreement. Hold a proposed edit when the clause has no applicable approved rule, the original and an exhibit conflict, an essential attachment is absent, a defined term changes meaning or existing revisions make the baseline unclear. Record the source words, reason and decision owner.
Have the matter owner confirm who may access the document and which processing environment is approved. This file is an instruction for review. It contains no technical enforcement and authorizes no service or model.
