Claude, Contract Review.
The video explains that a contract-review skill is a SKILL.md checklist, not a lawyer weighing every clause. The same contract gets the same flags each run, but anything the checklist never names stays invisible, so the read-through is still yours.
People often type it as a question: is Claude my contract's lawyer? The video answers no. What runs when you hand Claude a contract through a review skill is closer to a checklist, the same steps every time. The more useful question is what that checklist catches and what it misses.
The natural guess
The natural assumption is that Claude reads a contract the way a lawyer would, weighing the whole document clause by clause and case by case. The video sets this up as the common expectation before taking it apart. Between the contract and the review sits a written file, SKILL.md, and that file shapes everything that follows.
A skill is a folder, not a judgment call
A skill is a folder Claude reads before it acts. SKILL.md is the whole instruction set, written in plain language with no hidden logic. The pipeline is fixed: read the file, execute each step in order, and return the result. It is linear, with no branching unless a step says so.
The video draws the consequence directly. This is not judgment, it is a checklist written in advance. The trade-off is that it buys repeatable results, so the same input gets the same output on every run.
The freelance contract example
To make this concrete, the video runs a freelance contract through the skill. The termination clause comes back flagged. The checklist says to look there, so it looks.
The checklist, however, only names what it names. The video's example is an arbitration clause that the list never mentions. That clause gets no comment, and the reason is not that it is fine. It is simply off the list.
What a flag and a clean pass mean
Run the same contract again and the termination flag comes back identical. The video calls that consistency. A flag means a listed check matched, which is not a verdict on the contract.
The same logic applies in the other direction. A clean pass is not a clean bill of health. It means nothing on the list tripped. Whatever is off the list stays invisible either way, whether the result is a flag or a pass.
Key takeaways
- Claude with a review skill behaves like a contract checklist, not a contract lawyer.
- A skill is a folder, and SKILL.md holds the full instructions in plain language.
- The pipeline is read the file, execute each step in order, return the result.
- A fixed checklist trades judgment for repeatable results.
- A flag means a listed check matched, not that the contract is good or bad.
- A clean pass means nothing on the list tripped, and nothing more.
- Clauses the checklist never mentions, such as arbitration in the example, get no comment.
- The read-through of the contract is still the reader's job.
Try it yourself
Paste the video's prompt into Claude along with any contract you are reviewing: ask it to list exactly what it will check for and what it will not, and only then do the review. That first list turns an invisible checklist into one you can see, so you know what the review can and cannot cover before you rely on it. The skill's code is in the humanitarians-youtube repository.
Chapters
Full transcript(auto-generated, with timestamps)
Is Claude my contract's lawyer?
[0:00]People type it like this, is Claude my contracts lawyer? It isn't. It's my contracts checklist, the same steps every single time. So, what does that checklist actually catch and what does it miss? People hand Claude a contract expecting a review. What actually runs in between is a written file, skill.md.
The natural guess — read it all, weigh it, decide
[0:17]The natural assumption, Claude reads it like a lawyer would, weighing the whole document clause by clause, case by case.
A skill is a folder, not a judgment call
[0:24]A skill is a folder Claude reads before it acts. Skill.md is the whole instruction set, plain language, no hidden logic. The pipeline is fixed, read the file, execute each step in order, return the result. Linear, no branching unless a step says so. So, it isn't judgment, it's a checklist written in advance. That trade buys repeatable results, the same input gets the same output every run.
The anchor — a freelance contract, flagged
[0:48]Run it on a freelance contract and it flags the termination clause. The checklist says, look there, so it looks. But, the checklist only names what it names. An arbitration clause the list never mentions gets no comment, not because it's fine.
The anchor returns — same flag, not a verdict
[1:02]Run the same contract again, the termination flag comes back identical. That's consistency, a flag means a listed check matched, not a verdict on the contract. And a clean pass isn't a clean bill of health, either. It means nothing on the list tripped. What's off the list stays invisible, either way. A
Carry-out
[1:19]Skill.md gives Claude the same checklist every time, that's consistency, not judgment. So, the read-through is still yours.
Your turn
[1:26]Your turn, paste this into Claude along with any contract you're reviewing. Before you review this, list exactly what you will check for and what you will not. Then do the review. That first list turns an invisible checklist into one you can see.
Outro
[1:39]Claude contract review, the checklist, not the lawyer. Liam in for Bear.





