Abra os dois documentos do Word para acompanhar uma primeira revisão completa. No acordo piloto recebido, a Example Buyer tem três dias úteis para revisar um relatório. A cópia revisada propõe dez, cita a regra do exercício em um comentário e deixa a renovação para decisão do jurídico. Ambos os arquivos contêm a mesma tabela de entregas.
Inspecione o exemplo fictício
Baixe o acordo recebido e a cópia para revisão ou use o ZIP para obter também as instruções e o verificador. O exemplo está em inglês nas seis edições deste guia. Você pode inspecioná-lo localmente sem conta do Claude ou documentos de clientes.
Mantenha o original intacto. Abra a cópia no Word e exiba todas as marcações e comentários. Na cláusula 2, encontre a exclusão de “three” e a inserção de “ten”. O comentário ao lado cita REVIEW-01 e pede ao jurídico que confira o prazo em relação ao cronograma do piloto.
Leia a cláusula 3. O texto sobre renovação permanece intacto, inclusive o aviso prévio de cinco dias. O segundo comentário, HOLD-01, pede uma decisão porque o manual do exercício não define uma posição sobre renovação. A cláusula 1 e a tabela não têm alterações propostas.
Faça duas cópias de teste do arquivo revisado. Rejeite ambas as revisões em uma e confira se a frase corresponde ao original. Aceite ambas na outra e confirme que apenas o prazo de revisão mudou. Inspecione os comentários separadamente. Ocultar a marcação não resolve uma revisão. Instruções da Microsoft para Word
Confira o que o arquivo preserva
Na pasta extraída do ZIP, execute python3 verify_sample.py. O Python 3 lê os dois arquivos do exemplo localmente. Um resultado aprovado começa com PASS: one replacement, two anchored comments. O script verifica a inserção e a exclusão nativas, as âncoras e referências dos comentários e o corpo do documento ao simular cada decisão. Também compara a tabela, os estilos e os demais componentes do pacote com o original.
Leia examples/review-notes.md junto com os documentos. As três entradas distinguem uma cláusula intacta, uma substituição proposta e uma decisão pendente. Os arquivos foram montados offline, renderizados para revisão visual e verificados estruturalmente. Isso verifica o par entregue. Não comprova que o Claude preserve qualquer documento nem que esses termos sirvam para um contrato real.
Use as instruções em um caso autorizado
Escolha este workflow quando o jurídico tiver aprovado um manual para aquele tipo de contrato e uma pessoa responsável puder revisar cada proposta. Se a minuta tiver revisões pendentes, anexos conflitantes, definições ausentes ou cláusula desconhecida, preserve o original e apresente essas questões antes de propor redação.
O SKILL.md descreve as etapas. Os três arquivos em references/ fornecem a regra fictícia, o texto alternativo e a decisão de encaminhamento. Substitua-os pelas regras aprovadas da organização, pelo texto exato, pela versão, pelo responsável e pelos critérios de encaminhamento antes de trabalhar em um NDA ou MSA real. O prazo de dez dias do exercício não é uma posição padrão para outros acordos. O procedimento de revisão contratual pode ajudar a definir a passagem de responsabilidade.
Confirme que o responsável pelo caso autoriza a conta e o tratamento dos documentos. O Skill fornece instruções escritas. Ele não impõe políticas de conta, verifica sigilo profissional, conecta um CLM ou transmite minutas. Quem usa Claude precisa de um editor aprovado que preserve os recursos existentes do Word. Se houver apenas texto simples, entregue notas por cláusula para inserir as propostas no Word. Preserve marcações anteriores, referências cruzadas, anexos, comentários e definições em uma versão separada.
Decida se vale adotar
Faça um piloto com material autorizado. Registre questões omitidas, substituições incorretas, propostas sem fundamento, minutos de revisão e recursos danificados. Inclua cobranças de editor ou modelo e tempo do jurídico na comparação com o processo atual. O exemplo não mediu contratos reais, custo de fornecedor, economia de tempo ou resultados jurídicos.
O jurídico decide sobre cada proposta e resolve todas as pendências. O responsável pelo caso controla a liberação. Antes de compartilhar, revise a versão final, os comentários, os metadados e os destinatários pelo processo normal da organização.
# 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.