A Contract Review Prompt That Triages Risky Clauses by Severity

Legal teams and founders without legal teams share a bottleneck: inbound contracts pile up, each one needs a read, and the read is slow. The pages ranking for contract review prompt mostly explain why you shouldn't use ChatGPT for it, then point at their own legal-AI product. They're not wrong about the limits. They're just not giving you the one thing that's genuinely useful: a prompt that triages a contract so you know where to spend a lawyer's hour.

That's the honest framing. A model can't redline like a senior associate who knows your risk tolerance and the deal's commercial priorities. It can read every clause, flag the ones that deviate from a standard position, rank them by how much they'd hurt, and draft a starting redline. Triage, not judgment. A contract review prompt built for triage saves the expensive review for the clauses that actually warrant it.

This post builds that prompt: the severity output contract, the patterns that keep it grounded, and the hard limits you respect or get burned by.

What a contract review prompt does

A contract review prompt is a reusable instruction that reads a contract, extracts the operative clauses, scores each against your standard positions, ranks the risk by severity, and suggests a redline per flagged clause.

The value is in the triage structure:

1. Extraction with silence detection. It pulls the operative clauses and, crucially, flags standard protections that are missing. A missing limitation-of-liability clause is a risk the contract won't announce.
2. Scoring against your positions. "Risky" is relative to your paper. The prompt scores deviations from what you'd normally accept, sized to the deal.
3. Severity ranking. High/medium/low, so a draconian indemnity clause doesn't get the same attention as an awkward notice period.
4. Suggested redlines. A starting edit per flagged clause, with the reasoning, so a human isn't drafting from a blank page.

Why the ranking pages don't ship this: their incentive runs the other way. Juro's guide gives three generic prompt templates ("flag any clauses that could expose Company A to risk") but none with severity ranking or redlines, and it pivots to Juro's own review agent (juro.com). Spellbook's risk-analysis piece is explicit that ChatGPT "lacks" jurisdiction-specific review and positions its own legal-grade tool instead, offering no copyable severity-scored prompt (spellbook.com). The caution is fair. The omission is convenient.

What you can do with this prompt

• Triage an inbound NDA or MSA in an hour and walk into counsel knowing the three clauses that matter.
• Catch missing standard protections, not just bad ones that are present.
• Generate first-draft redlines so the lawyer edits instead of drafts.
• Normalize how clauses get flagged across a high volume of similar agreements.
• Brief a non-legal stakeholder in plain English on what they're about to sign.
• Build a consistent record of which deviations you pushed back on and why.

Anatomy of the prompt

The severity output contract is what separates a triage tool from a glorified summarizer. Structure:

Variables
  {{contract_text}}        → the pasted contract
  {{contract_context}}     → deal size, what you're getting, your priorities
  {{your_paper_or_theirs}} → whose template this is (changes the default bar)

Prompt
  Role: contract triage analyst preparing a deal memo for legal review.
  Task: extract operative clauses from {{contract_text}}, flag missing
        standard protections, score each risk by severity against your
        positions, and suggest a redline per flagged clause.
  Rules: never state a legal conclusion as certain. Quote the clause text.
         Size consequences to {{contract_context}}, not in the abstract.

Output contract (table):
  | Clause | Risk created | Severity | Suggested redline | Why it matters here |

The "Why it matters here" column ties the abstract risk to the actual deal. A liability cap that's fine for a $5k pilot is unacceptable for a $2M commitment, and the prompt should say so because you fed it {{contract_context}}.

Where the output contract goes in the prompt

For a long contract, put the output contract after the pasted {{contract_text}}, on the final lines. Models weight the most recent tokens, so a contract specified first and a 30-page agreement pasted after will get a drifting, half-formatted result. Claude holds a ## Output format table across a long document more reliably than GPT-4o, which often needs the table headers restated on the last line to stop it summarizing instead of tabulating.

Step-by-step usage

1. Set the deal context honestly

{{contract_context}} is what makes the severity meaningful. Deal size, what you're actually buying, what you can't live without. Without it, every clause gets generic-risk scoring that doesn't help you prioritize.

2. Note whose paper it is

{{your_paper_or_theirs}} flips the default bar. On their template, expect more deviations from your positions and weight the silence-detection harder; standard protections you'd include are often quietly absent.

3. Paste and run with the contract last

Drop the contract into {{contract_text}}, keep the output contract on the final lines, and run. Read the high-severity rows first.

4. Sanity-check the legal claims

This is non-negotiable. The model will sometimes assert a legal position confidently and wrongly. Scan each "Risk created" cell with a skeptical eye, and flag anything that smells like a hallucinated rule for the lawyer.

5. Hand the redlines to counsel

Take the suggested redlines as a starting draft, not a final one. Your lawyer edits from there. The triage already told them where to look, which is the whole point.

Prompt-craft patterns

Force clause quoting. Grounding each flagged risk in the actual clause text stops the model from inventing a problem that isn't in the contract.

For every flagged clause, quote the exact contract language. If you
cannot quote it, do not flag it. No risk without a source clause.

Detect silence explicitly. Tell the model which standard protections to check for, so a missing one shows up as a high-severity gap rather than an absence nobody notices.

Check whether these standard protections are present: limitation of
liability, indemnity cap, termination for convenience, IP ownership.
List any that are absent as a separate "missing protections" section.

Ban certainty on legal conclusions. A triage prompt that hedges its legal claims is safer and, frankly, more honest about what a model can know.

Never state a legal conclusion as certain. Use "this appears to" and
flag anything jurisdiction-specific as "confirm with counsel."

Variables you'll set

Getting started

1. Confirm the contract can safely go into your chosen model and tier.
2. Write {{contract_context}} with the real deal size and priorities.
3. Set {{your_paper_or_theirs}} so the scoring uses the right bar.
4. Paste the contract and run with the output contract on the final lines.
5. Read the high-severity rows and sanity-check every legal claim.
6. Pass the suggested redlines to counsel as a starting draft.
7. Keep the triage register as your record of what you pushed back on.

Tuning the silence detection, the consequence sizing, and the negotiation ladder by hand takes a few iterations. The pack version ships it tuned and adds the parts a single prompt can't.

Risk triage shows up across business functions, not just contracts. The same severity-output discipline drives the SOC 2 readiness prompt for compliance gaps and the vendor security assessment prompt for third-party risk. If you build decisions off the triage, a structured decision aid keeps the call honest, and the Decision Pros & Cons free pack is a clean place to start before you commit to the redline.