Contract Review

⚠️ EXPERIMENTAL — This skill is provided for educational and informational purposes only. It does NOT constitute legal advice. All responsibility for usage rests with the user. Consult qualified legal professionals before acting on any output.

Contract Review

Automated contract review tools that analyze agreements against organizational playbooks, classify clause risk with GREEN/YELLOW/RED severity, and generate prioritized redline suggestions with fallback positions.

Table of Contents

• Tools
  • Contract Analyzer
  • Redline Generator
• Reference Guides
• Workflows
  • Standard Contract Review
  • Rapid Risk Triage
• Troubleshooting
• Success Criteria
• Scope & Limitations
• Anti-Patterns
• Tool Reference

Clarify First

Before reviewing the contract, confirm these inputs. If any is unknown or vague, ASK — do not assume:

• Which side you represent — customer/buyer vs vendor/provider flips which clauses are favorable and reverses the direction of every redline
• Contract type — SaaS, services, vendor/supply, or license — sets the standard-clause baseline and which missing clauses get flagged
• Risk tolerance / playbook positions — what your org treats as a deal-breaker — defines the RED vs YELLOW cutoff and the Must-Have vs Nice-to-Have tiering
• Deal leverage / value — calibrates which redlines are walkaway (Tier 1) vs tradeable concessions (Tier 3)

Stop rule: ask only the 2-3 that most change the output. If the user says "just draft it," proceed and list your assumptions at the top of the review.

Tools

Contract Analyzer

Analyzes contract text files for clause types, missing standard clauses, and risk indicators.

# Analyze a contract file
python scripts/contract_analyzer.py contract.txt

# JSON output for pipeline integration
python scripts/contract_analyzer.py agreement.md --json

# Save analysis to file
python scripts/contract_analyzer.py contract.txt --output analysis.json --json

What it detects:

• Clause types: Limitation of Liability, Indemnification, IP, Data Protection, Term & Termination, Governing Law, Reps & Warranties, Force Majeure, Confidentiality, Payment Terms
• Missing standard clauses against a baseline checklist
• Risk indicators: uncapped liability, perpetual terms, unilateral indemnification, automatic renewal without opt-out, broad IP assignment, unlimited audit rights

Risk Classification:

Redline Generator

Takes contract analysis JSON and generates formatted redline suggestions with priority tiers.

# Generate redlines from analysis
python scripts/contract_analyzer.py contract.txt --json --output analysis.json
python scripts/redline_generator.py analysis.json

# JSON output
python scripts/redline_generator.py analysis.json --json

# Save redlines to file
python scripts/redline_generator.py analysis.json --output redlines.md

Output includes:

• Priority tier (Must-Have / Should-Have / Nice-to-Have)
• Preferred redline language
• Rationale for each change
• Fallback position if counterparty rejects
• Negotiation notes

Priority Tiers:

Reference Guides

Clause Analysis Guide

references/clause_analysis_guide.md

Deep reference covering 8+ clause types:

• Limitation of Liability (cap types, carveouts, consequential damages)
• Indemnification (mutuality, scope, procedure)
• IP (ownership, licenses, work-for-hire, feedback)
• Data Protection (DPA, sub-processors, breach notification, transfers)
• Term & Termination (auto-renewal, cure periods, transition)
• Governing Law (jurisdiction, arbitration, jury waiver)
• Representations & Warranties
• Force Majeure

Negotiation Playbook

references/negotiation_playbook.md

Negotiation priority framework with:

• Tier 1 deal-breakers and walkaway criteria
• Tier 2 strong preferences with trading strategies
• Tier 3 concession candidates for strategic give-backs
• Redline format template
• Common negotiation pitfalls

Workflows

Standard Contract Review

1. Ingest -- Save contract as .txt or .md file
2. Analyze -- Run contract_analyzer.py with --json flag
3. Review findings -- Check RED items first, then YELLOW
4. Generate redlines -- Run redline_generator.py on analysis output
5. Prioritize -- Focus on Must-Have redlines, prepare fallbacks for Should-Have
6. Send to counsel -- Attach analysis and redlines for final review

Rapid Risk Triage

1. Run contract_analyzer.py in text mode for quick scan
2. If any RED findings: escalate immediately to legal counsel
3. If YELLOW only: schedule review within 48 hours
4. If all GREEN: proceed with standard approval workflow

Troubleshooting

Success Criteria

• Contract review time reduced by 50%: Automated clause identification and risk classification eliminates manual scanning.
• Zero missed RED-severity clauses: Every uncapped liability, unilateral indemnification, and broad IP assignment is flagged before human review.
• Redline generation under 2 minutes: From analysis JSON to prioritized redline document.
• Consistent risk classification across reviewers: GREEN/YELLOW/RED framework eliminates subjective assessments.
• 100% of contracts reviewed with structured output: Every agreement gets a clause inventory and risk report before negotiation begins.
• Negotiation success rate above 80% on Must-Have items: Tier 1 redlines with prepared fallbacks improve negotiation outcomes.

Scope & Limitations

Covers:

• Static text analysis of contract clauses using keyword and pattern matching
• Clause type identification across 10+ standard commercial contract categories
• Risk indicator detection: uncapped liability, perpetual terms, unilateral obligations, auto-renewal traps
• Missing clause detection against a standard commercial contract baseline
• Prioritized redline generation with fallback positions

Does NOT cover:

• Legal advice -- this tool supports review, it does not replace qualified legal counsel
• Jurisdiction-specific compliance -- use ra-qm-team skills for regulatory compliance (GDPR, SOC 2, etc.)
• Contract execution or e-signature workflows -- out of scope
• Multi-document cross-reference (e.g., checking SOW against MSA) -- analyze each document separately
• Non-English contracts -- pattern matching is English-language only

Anti-Patterns

Tool Reference

contract_analyzer.py

Purpose: Analyzes contract text files for clause types, identifies missing standard clauses, and flags risk indicators with GREEN/YELLOW/RED severity classification.

Usage:

python scripts/contract_analyzer.py <contract_file> [--json] [--output FILE]

Flags:

Example Output (JSON):

{
  "file": "vendor_agreement.txt",
  "clauses_found": [
    {
      "type": "limitation_of_liability",
      "severity": "RED",
      "text_snippet": "...liability shall not be limited...",
      "risk_flags": ["uncapped_liability"],
      "notes": "No liability cap found; uncapped exposure"
    }
  ],
  "missing_clauses": ["force_majeure", "data_protection"],
  "risk_summary": {"RED": 2, "YELLOW": 3, "GREEN": 5},
  "overall_risk": "RED"
}

redline_generator.py

Purpose: Takes contract analysis JSON and generates formatted redline suggestions with priority tiers, rationale, and fallback positions.

Usage:

python scripts/redline_generator.py <analysis_json> [--json] [--output FILE]

Flags:

Example Output:

REDLINE SUGGESTIONS
===================

[MUST-HAVE] Limitation of Liability — Uncapped Liability
  Severity: RED
  Preferred: "Aggregate liability shall not exceed 12 months of fees paid."
  Rationale: Uncapped liability creates unlimited financial exposure.
  Fallback: "Aggregate liability shall not exceed 24 months of fees paid."

[SHOULD-HAVE] Indemnification — Unilateral Indemnification
  Severity: YELLOW
  Preferred: "Each party shall indemnify the other for breaches of this Agreement."
  Rationale: Mutual indemnification balances risk between parties.
  Fallback: "Indemnification obligations shall be subject to the liability cap."