Abre los dos documentos de Word para seguir una primera revisión completa. En el acuerdo piloto recibido, Example Buyer tiene tres días hábiles para revisar un informe. La copia revisada propone diez, cita la regla del ejercicio en un comentario y deja la renovación pendiente de decisión legal. Ambos archivos contienen la misma tabla de entregas.
Inspecciona el ejemplo ficticio
Descarga el acuerdo recibido y la copia para revisión, o usa el ZIP para obtener también las instrucciones y el verificador. El ejemplo está en inglés en las seis ediciones de esta guía. Puedes inspeccionarlo localmente sin cuenta de Claude ni documentos de clientes.
Conserva intacto el original. Abre la copia en Word y muestra todas las marcas y comentarios. En la cláusula 2, busca la eliminación de “three” y la inserción de “ten”. El comentario contiguo cita REVIEW-01 y pide al equipo legal contrastar el plazo con el calendario del piloto.
Lee la cláusula 3. Se mantiene el texto de renovación, incluido el preaviso de cinco días. El segundo comentario, HOLD-01, solicita una decisión porque el manual del ejercicio no define una posición sobre renovación. La cláusula 1 y la tabla de entregas quedan sin propuestas de cambio.
Crea dos copias de prueba del archivo revisado. Rechaza ambas revisiones en una y comprueba que la frase coincide con el original. Acepta ambas en la otra y confirma que solo cambia el plazo de revisión. Inspecciona los comentarios por separado. Ocultar las marcas no resuelve una revisión. Instrucciones de Microsoft para Word
Verifica qué conserva el archivo
Desde el ZIP extraído, ejecuta python3 verify_sample.py. Python 3 lee localmente los dos archivos del ejemplo. Un resultado correcto comienza con PASS: one replacement, two anchored comments. El script comprueba la inserción y eliminación nativas, las anclas y referencias de los comentarios y el cuerpo del documento al simular cada decisión. También compara la tabla, los estilos y los demás componentes del paquete con el original.
Lee examples/review-notes.md junto con los documentos. Sus tres entradas distinguen una cláusula intacta, una sustitución propuesta y una decisión pendiente. Los archivos se prepararon sin conexión, se renderizaron para revisar el diseño y se comprobó su estructura. Esto verifica el par entregado. No demuestra que Claude pueda conservar cualquier documento ni que estos términos sean apropiados para un acuerdo real.
Usa las instrucciones en un asunto autorizado
Elige este workflow cuando el equipo legal haya aprobado un manual para ese tipo de acuerdo y una persona responsable pueda revisar cada propuesta. Si el borrador contiene revisiones pendientes, anexos contradictorios, definiciones faltantes o una cláusula desconocida, conserva el original y presenta esas cuestiones antes de proponer texto.
SKILL.md describe los pasos. Los tres archivos de references/ contienen la regla ficticia, el texto alternativo y la decisión de escalar. Sustitúyelos por las reglas aprobadas de tu organización, el texto exacto, la versión, el responsable y los criterios de escalamiento antes de trabajar con un NDA o MSA real. El plazo de diez días del ejercicio no es una posición predeterminada para otros acuerdos. El procedimiento de revisión contractual puede ayudarte a definir el traspaso.
Confirma que el responsable del asunto permite usar esa cuenta y ese tratamiento documental. El Skill aporta instrucciones escritas. No puede imponer políticas de cuenta, verificar el secreto profesional, conectarse a un CLM ni transmitir un borrador. Quien use Claude necesita un editor aprobado que conserve los elementos existentes de Word. Si solo dispone de texto plano, debe entregar notas por cláusula para introducir las propuestas en Word. Conserva en una versión separada las marcas anteriores, referencias cruzadas, anexos, comentarios y definiciones.
Decide si adoptarlo
Haz una prueba con material autorizado. Registra cuestiones omitidas, sustituciones incorrectas, propuestas sin fundamento, minutos de revisión y elementos dañados. Incluye los cargos del editor o modelo y el tiempo del equipo legal al comparar con el proceso actual. El ejemplo no midió contratos reales, costos de proveedor, ahorro de tiempo ni resultados legales.
El equipo legal decide sobre cada propuesta y resuelve todos los asuntos pendientes. El responsable del asunto controla la entrega. Antes de compartir, revisa la versión final, los comentarios, los metadatos y los destinatarios según el proceso de la organización.
# 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.