Choreography: contract review with a checklist
AI does the first pass on a contract and flags the risk clauses; you review what it flagged, checklist in hand, and decide what's real risk. What used to take hours of reading becomes minutes, and you focus on the judgment call.
A twelve-page service agreement lands on your desk for you to review by tomorrow. You know what to look for: payment terms, termination penalty, venue, confidentiality clause, liability cap. But it's twelve pages of legalese, and reading it all carefully takes two, three hours. You open AI, paste the whole contract, and ask for the first pass. In minutes it hands back the clauses that deviate from the standard, the vague terms, and what's missing. That's where your real work begins: deciding what's actual risk.
Think with me: a resume and interview history for a senior candidate lands on your desk, and you need to give your assessment by tomorrow. You throw it all into AI and ask for the first pass. In minutes it flags: experience gaps, short job stints, a skill from the job description that doesn't show up anywhere. That's scanning, and it does it fast. But deciding whether that job stint is a red flag or just a restructuring that caught the candidate up, that's reading people and context. That's yours. You cross what it flagged against your competency checklist and decide who moves forward.
Imagine a batch of forty feature requests lands for you to prioritize on next quarter's roadmap. You throw the list into AI and ask it to flag: what conflicts with the product vision, what doesn't have a defined success metric, what overlaps with something already in the backlog. In minutes it scans everything and marks the points. Fine, but deciding what actually makes the roadmap, what moves the metric that matters this quarter, that's product judgment, it's yours. You take its scan, cross it with your prioritization checklist, and decide what gets built.
Think of a ninety-thousand-dollar proposal that came in from the supplier for you to close by tomorrow. It's eight pages of terms, deadlines, and SLAs, and reading it all by hand costs you the afternoon. You throw the proposal into AI and ask for the first pass. In minutes it flags: the payment term is shorter than usual, the late-delivery penalty is missing, there's an index-linked adjustment that's out of step with the market. That's scanning. But deciding what to negotiate, how far to bend, and what's a dealbreaker for this client, that's negotiation strategy, it's yours. You cross what it flagged against your proposal checklist and walk into the room knowing where to push.
Think with me: a fifteen-page logistics operator contract lands in your hands for you to approve before they become a partner. You throw it into AI and ask for the scan. In minutes it flags: the delivery SLA has no defined penalty, the acceptable damage rate is above your standard, there's no contingency plan clause. That's scanning gold. But deciding whether that loose SLA is real risk for your operation or a detail you can absorb, that's reading your process and your volume. That's yours. You cross it with your operational checklist and decide what you're willing to run with.
Imagine a data-processing agreement with a new vendor lands for you to give a risk opinion on. You throw it into AI and ask for the first pass. In minutes it flags: the legal basis for processing is missing, the data retention period isn't defined, the subcontracting clause doesn't mention consent. That's scanning, and it doesn't skip a paragraph. But deciding whether that missing legal basis is a blocker that stops the contract or an adjustment fixed with an addendum, that's regulatory risk judgment. That's yours. You cross what it flagged against your data-privacy checklist and decide what becomes a requirement.
Think of a big pull request that landed for you to review before deploy: two hundred lines changed across three services. You throw the diff into AI and ask for the first pass. In minutes it flags: a query without an index that could lock up production, a hardcoded secret in the code, a call with no error handling. That's scanning, and it reads everything without getting tired. But deciding whether that slow query is real risk at your traffic volume or a path almost nobody hits, that's reading your architecture. That's yours. You cross what it flagged against your review checklist and decide what holds the merge.
Think with me: you need to review the checkout flow of a prototype before sending it to development. You throw the screens and the flow into AI and ask for the first pass. In minutes it flags: a step with no error state, a button with no accessible label, a step that asks for data the user already gave earlier. That's scanning, it doesn't let a screen slide. But deciding whether that friction in the third step is what tanks conversion or a minor detail, that's reading your user and the journey. That's yours. You cross what it flagged against your usability checklist and decide what gets fixed before moving on.
Imagine a target startup's forty-page business plan lands on your desk, and you owe the board a first M&A opinion by tomorrow. You throw the document at AI and ask for the scan. Within minutes it flags: the growth projection doesn't match the three-year history, the cited TAM has no source, there's a single-client dependency that accounts for forty percent of revenue. That's scanning, and it never gets tired of cross-checking numbers against numbers. But deciding whether that client dependency tanks the valuation or is a risk that gets solved with an earnout clause, that's business judgment, and it's yours. You cross-check what it flagged against your strategic due diligence checklist and decide what makes it into the opinion for the board.
Let me ask you something: how much of your contract review is manual reading and how much is judgment? Yeah, when I stop to measure it, the math is scary. Two hours reading line by line so that, in the end, what actually matters is half a dozen decisions: I accept this penalty, I negotiate this deadline, I kill this venue clause. Reading is the heavy lifting; deciding is your work. And reading is exactly what AI does fast. Think of it as the intern who reads the whole contract and hands it back to you marked up: "look here, here, and here." Who decides what to do with each mark is still you.
The core idea of this lesson. Reviewing a contract with AI is a four-step choreography. First AI does the pass: it reads the whole contract, flags the risk clauses, the vague terms, and what's missing. Then you review what it flagged, checklist in hand. Then you decide: what's real risk, what to negotiate, what to accept. And in the end the document goes through an audit, because AI points things out, it doesn't conclude. The division is clear: AI speeds up the scanning; the risk judgment and negotiation strategy are yours. What used to take hours of reading becomes minutes of scanning, and you spend your time where it pays off: deciding.
01The first pass is AI's, the judgment is yours
The temptation is to ask AI to "review the contract and tell me if it's good." Wrong. That's asking it to decide the risk, and risk is your part. The right request is more humble and more useful: "read this whole contract and flag the risk clauses, the vague terms, what's missing, and what deviates from a standard contract of this type." Notice the difference. You're not asking for a conclusion. You're asking for a scan.
AI is good at this because it reads twelve pages without getting tired, doesn't skip a paragraph, and compares against thousands of contracts it has already seen. It flags: "clause 8 has no liability cap," "the payment term is 60 days, above the usual," "the term 'at the contracting party's discretion' appears three times with no definition." That's scanning gold. But none of these flags is a decision. Deciding whether 60 days is acceptable for this client, or whether that "at the contracting party's discretion" is a landmine or just boilerplate, is reading context and risk. That's yours.
You're the one who gives it the context to flag the right things, and that connects directly to lesson 2.1 of this course: AI only flags well what you show it. State the type of contract, which side you represent, what matters in this deal. Without context, it does a generic pass; with context, it flags what's relevant to your case.
02The checklist is your hand in the review
AI flags dozens of points. Without a filter, you drown in them. The filter is your checklist: the list of what matters for this type of contract. In a service agreement, your checklist might be payment terms, termination penalty, liability cap, ownership of what gets produced, confidentiality, venue, and price adjustment. Every type of contract has its own.
The checklist does two things that a loose scan doesn't. First, it prioritizes: of the forty points AI flagged, which are the seven that decide the deal. Second, and more important, it catches what's missing. AI flags what's in the contract; the checklist flags what should be there and isn't. If your checklist has "confidentiality clause" and it doesn't show up in the scan, that's an absence, and an absence tends to be the most expensive risk, because it's invisible until someone looks for it.
Where this fools you: it's easy to confuse "AI didn't flag it" with "there's no problem." It's not the same thing. AI flags what's written; it doesn't guarantee that what's missing was noticed. The checklist is exactly the instrument that turns silence into a question: "where's the adjustment clause?" What protects you isn't AI's scan alone, it's the scan cross-checked with your checklist.
03The choreography, from contract to decision
Put it all together and it becomes a flow. The contract comes in, AI does the pass and flags risk clauses and absences, you cross what it flagged against your checklist, and then you decide each point: real risk, negotiate, or accept.
Notice where the boundary sits in the diagram. The two middle boxes, the pass and the validation, are where AI speeds things up and your checklist filters. The last box, the decision, is yours alone. AI might even suggest "this clause is usually negotiated," but deciding to negotiate, on what terms, and how far to bend is strategy, and strategy is reading people and business, not text. That's the point you don't outsource.
04The document goes through an audit: it points, you verify
This is the module's rule, and it applies here in full: AI points things out, it doesn't conclude. Every legal document that leaves your hands goes through an audit, and in this choreography the audit is you verifying what AI flagged before acting. Did it say "clause 8 has no liability cap"? You open clause 8 and check it with your own eyes. Did it say "the deadline is above the usual"? You check the number in the contract.
Why verify, if it usually gets the scan right? Because the cost of being wrong here is asymmetric. A misread clause in a signed contract isn't an email with a typo, it's real exposure, money, and litigation. When the error is expensive and irreversible, you verify. AI cut your three hours of reading down to twenty minutes of assisted scanning; using the minutes you saved to check the hot points isn't waste, it's what makes the speed safe. This discipline of auditing the document is the entire subject of lesson N.jur.7 of this course; for now, it's enough that you leave knowing that an AI flag isn't a verdict, it's a lead to verify.
Do it now
Take your real task: a real contract you need to review (or a recent one you already reviewed, to compare). Run the choreography end to end:
- First pass. Paste the whole contract into AI and ask for the scan, not the conclusion: "read this [type] contract, I represent the [your side] side. Flag risk clauses, vague terms, what's missing, and what deviates from a standard contract of this type. Don't conclude whether it's good or bad."
- Checklist in hand. List 5 to 8 points that matter for this type of contract (deadline, penalty, liability, confidentiality, venue...). Cross it against the scan: what did AI flag that's on your checklist? And what's on your checklist that it didn't flag, meaning, what's missing from the contract?
- Decide. For each point that matters, write one word: accept, negotiate, or risk. That column is yours alone.
- Audit. Take the 3 hottest points and check each one directly against the contract text, with your own eyes.
Compare the time: how long it would take reading everything by hand, versus how long it took with AI's pass plus your decision.
Practice
1. What is the right request for AI's first pass on a contract?
2. What is the checklist for in the review, besides prioritizing the points AI flagged?
3. AI didn't flag any problem in a clause. What does that guarantee?
For the board
On the divisionAI does the first pass and flags the points; the risk judgment and negotiation strategy are yours. The scan is AI's, the decision is yours.
On the checklistit prioritizes what matters and, most importantly, catches what's missing. AI flags what's written; the checklist flags the absence.
On the auditAI points things out, it doesn't conclude. A flag is a lead to verify, not a verdict. You check the hot points with your own eyes.
To take with youwhat used to take hours of reading by hand becomes minutes of assisted scanning, and you spend your time where it pays off: deciding. Fair? Next up.
Thanks for the feedback. It helps sharpen the next lesson.