Introduction
Analyzing commercial contracts consumes significant time in legal teams — identifying termination clauses, auto-renewal deadlines, penalties, or incompatibilities requires careful reading of dozens of pages. Language models (LLMs) like GPT-4 or Claude can accelerate this process, but analysis quality depends directly on prompt structure. This guide shows you how to build effective instructions to extract critical information and flag points of concern.
Why Prompt Engineering is Critical for Contracts
An LLM without adequate context can:
- Omit subordinate clauses that alter primary obligations
- Interpret ambiguous language without flagging the ambiguity
- Confuse cross-references between sections
- Generate generic summaries that don't highlight specific risks
Well-structured prompts transform the model into an assistant that:
- Extracts specific clauses with reference to the original section
- Identifies risk patterns (e.g., auto-renewal without prior notice)
- Compares terms with market standards when instructed
- Flags vague or potentially problematic language
Base Structure for a Contract Prompt
1. Define the Role and Context
Start by establishing the framework:
``` You are a legal assistant specializing in B2B commercial contract analysis. Your objective is to identify critical clauses and potential risks. Always respond with references to sections in the original document. ```
This establishes the domain (commercial B2B, not employment or real estate) and the expectation of accuracy (cite sections).
2. Specify the Task with Granularity
Avoid "analyse this contract." Request specific actions:
``` Analyse the attached contract and extract:
- Initial term and renewal conditions (identify if automatic)
- Termination clauses (notice periods, penalties)
- Exclusivity or non-compete obligations
- Liability limits and indemnities
- Conditions for unilateral amendment of terms
```
Each point should correspond to a risk category you typically manage.
3. Establish Output Format
LLMs tend to generate flowing text. Structure the response:
``` For each clause identified, use this format:
Category: [Renewal / Termination / Liability / etc] Location: Section X, paragraph Y Relevant text: [direct quote of the clause] Attention level: Low / Medium / High Justification: [why it deserves attention] ```
This facilitates quick review and allows you to use the output in structured reports.
Practical Example: Auto-Renewal
Basic Prompt (to avoid)
``` Does the contract auto-renew? ```
Typical response: "Yes, the contract has automatic renewal."
Effective Prompt
``` Identify renewal clauses in the contract. For each one:
- Provide the complete literal text of the clause
- Indicate the exact section and paragraph
- Identify whether there is automatic renewal
- If yes, check:
- Notice period to prevent renewal - If notice must be written / registered - Penalties for non-renewal - Price changes on renewal
Flag with [ATTENTION] if:
- Automatic renewal without mandatory prior notice
- Notice period exceeding 60 days
- Automatic price increases without limits
```
Structured response allows immediate decision on term acceptance.
Advanced Techniques
Chain-of-Thought for Complex Clauses
When a clause has chained conditions, request explicit reasoning:
``` Analyse the termination clause in Section 8. Before summarising:
- List all conditions that permit unilateral termination
- For each condition, identify timelines and procedures
- Check if clauses in other sections modify these terms
- Identify ambiguities or undefined terms
Only then present the structured summary. ```
This reduces omissions in dense legal language.
Few-Shot Learning with Examples
If you have previously analysed contracts, include examples:
``` Example of correct analysis:
Text: "The Supplier may change prices with 15 days' notice." Attention level: High Justification: Unilateral amendment without increase limit or right to immediate termination.
Now analyse the attached contract using the same criteria. ```
This calibrates the model to your internal standards.
Comparison with Reference Template
If you have preferred model clauses:
``` Preferred termination clause: "Either party may terminate with 30 days' written notice, without penalties."
Compare the termination clause in the attached contract against this standard. Identify:
- Deviations that increase risk (longer periods, penalties)
- Neutral deviations (notification format)
- Improvements over the standard
```
Common Points of Concern
1. Context Limitations
Long contracts (50+ pages) may exceed the model's context window. Solution: Divide into logical sections (general terms, financial annexes, special clauses) and analyse separately, then request consolidation.
2. Cross-References
Clauses like "subject to Section 12" require integrated reading. Solution: Explicitly instruct: ``` If a clause references another section, quote both and explain how the second modifies the first. ```
3. Ambiguous Language
Terms like "reasonable time" or "commercially reasonable efforts" are subjective. Solution: ``` Flag with [AMBIGUOUS] any undefined or subjective term that could generate disputes over interpretation. ```
Suggested Workflow
- First pass — Structured extraction:
- Use detailed prompt to identify all clauses in critical categories - Export result in tabular format (Markdown or JSON)
- Second pass — Risk verification:
- List clauses with "Attention level: High" - Request detailed analysis of each with citation of relevant case law (if the model was trained with this capability)
- Human review:
- Validate citations (LLMs can occasionally "hallucinate" sections) - Confirm interpretation in cases of ambiguous language - Decide on acceptance or negotiation
Tools and Integrations
To implement this in production:
- LLM APIs: OpenAI API (GPT-4), Anthropic API (Claude 3 Opus has 200k token window, useful for long contracts)
- OCR: If working with scanned PDFs, use Tesseract or Azure Form Recognizer before sending to LLM
- Validation: Compare model output against internal checklist using simple scripts
Limitations and Ethical Consideration
LLMs do not replace qualified legal review:
- They don't understand specific business context (e.g., whether a 90-day period is critical to your operations)
- They can err in interpreting archaic or poorly drafted language
- They don't have access to updated case law (unless integrated with legal databases)
Use them as a first screening tool, not as the final decision-maker.
Watch confidentiality: if you send contracts to external APIs (OpenAI, Anthropic), confirm this doesn't violate client confidentiality agreements. Consider self-hosted models (Llama, Mistral) for ultra-sensitive data.
Conclusion
Effective prompt engineering for contracts requires:
- Specificity in the risk categories you're looking for
- Structured output format to facilitate review
- Explicit instructions on source citation and ambiguity flagging
- Mandatory human validation before decisions
Start by applying this guide's templates to 2–3 contracts you already know well. Adjust prompts based on omissions or false positives you identify. With iteration, you can reduce initial analysis time from hours to minutes — freeing time for negotiation and strategy, the parts of legal work that truly demand human expertise.