You have spent years developing playbooks, checklists, and internal know-how for reviewing contracts, triaging NDAs, or running due diligence. That knowledge lives in your head, in scattered documents, and in the memories of your team. Every time you ask an AI to help with legal work, you have to re-explain your approach from scratch.
Skills solve this problem. A skill is a structured instruction package that teaches an AI how to perform a specific task your way, every time. Once built, it activates automatically whenever the AI encounters a matching request.
This guide walks you through building your own legal skill from scratch. We will start with the fundamentals, work through a complete example — a term sheet review skill — and cover the patterns that separate a mediocre skill from a great one.
A skill is a folder. Inside it is a file called SKILL.md — a markdown document that contains a YAML header and structured instructions. YAML is a simple text format (just `key: value` pairs between two `---` lines) that sits at the top of your SKILL.md file and tells the AI your skill's name and when to use it. That is the only required element.
1nda-review/
2└── SKILL.mdFrom there, you can add complexity as needed:
1nda-review/
2├── SKILL.md # Required: instructions
3├── references/ # Optional: supporting documents
4│ ├── key-clauses.md
5│ ├── party-obligations.md
6│ └── standard-exceptions.md
7├── templates/ # Optional: output templates
8│ ├── mutual-nda.docx
9│ └── unilateral-nda.docx
10└── scripts/ # Optional: executable code
11 └── validate_data.pyThe AI loads these files using a principle Anthropic calls “progressive disclosure.” When you install a skill, the AI does not read the entire folder into memory at once. First, it reads only the name and description from the YAML header — just enough to decide whether this skill is relevant. If it is, the AI loads the SKILL.md instructions. If those instructions reference a file in references/, the AI pulls it in only at that point. This keeps things fast and focused.
The YAML header sits at the top of your SKILL.md file, between two lines of triple dashes. It has two required fields: name and description.
1---
2name: nda-review
3description: Review non-disclosure agreements against standard
4 market terms. Use when user uploads an NDA for review, asks
5 questions about NDA clauses, or requests NDA templates. Covers
6 mutual and unilateral NDAs for commercial transactions.
7---The name field is a kebab-case identifier — lowercase, hyphens instead of spaces, no underscores or capitals. It should match your folder name.
The description field is the most important thing you will write. This is how the AI decides whether to load your skill. Anthropic’s own guide puts it bluntly: the description must include both what the skill does and when to use it, including specific trigger phrases users might say.
Here is what makes a good description versus a bad one:
Good — specific, includes triggers:
1Review non-disclosure agreements against standard market terms.
2Use when user uploads an NDA for review, asks questions about
3NDA clauses, or requests NDA templates.Bad — vague, no triggers:
1Helps with NDA-related legal tasks.You can also add optional fields: license (MIT, Apache-2.0, AGPL-3.0), metadata with author and version info, and compatibility to note any environment requirements.
After the YAML header comes the body of your SKILL.md — the actual instructions the AI will follow. Think of this as an onboarding document for a very capable but context-free associate. You need to be explicit about what to do, in what order, and what the output should look like.
Here are the patterns that work, drawn from both Anthropic’s official legal skills and real-world examples.
Yes, it turns out legal disclaimers have found yet another place to live. Every legal skill should open with one. Not because the AI will sue you if you don't add a disclaimer, but because it sets the right expectations for anyone who uses your skill.
1> **Important**: This skill assists with legal analysis but does
2> not constitute legal advice. AI-generated analysis should always
3> be reviewed by a qualified attorney. Laws vary by jurisdiction;
4> this skill reflects general principles and may not apply to
5> your specific situation.Both Anthropic’s official legal plugin and Skala’s own skills use this pattern consistently.
The best legal skills do not dive straight into analysis. They start by gathering context. Anthropic’s contract-review skill asks for the user’s role and focus areas. Skala’s term-sheet-review skill asks whether you are an investor or a founder, and at what stage. An NDA skill by Jamie Tso asks whether you are the receiving or disclosing party.
This matters because the same document looks different depending on which side of the table you sit on. Build this into your skill:
1## Initial Questions
2
3Before beginning the review, ask:
41. What is your role? (e.g., disclosing party, receiving party)
52. What is the context? (e.g., commercial partnership, M&A,
6 employment)
73. Are there any specific concerns or focus areas?
84. What jurisdiction governs this agreement?Legal work follows processes. Your skill should mirror this. Number the steps, be specific about what happens at each stage, and mark critical steps.
Anthropic’s NDA triage skill uses a 10-point screening checklist. Skala’s SAFE review skill has three distinct entry points depending on the user’s request (template review, legal questions, or drafting). Here is a workflow pattern adapted for a general contract review:
1## Workflow
2
3### Step 1: Document Identification
4Identify the contract type, parties, and governing law.
5
6### Step 2: Clause-by-Clause Analysis
7Review each clause against the playbook (see references/).
8For each clause, document:
9- Current language
10- Market standard position
11- Deviation (if any)
12- Risk rating: GREEN / YELLOW / RED
13- Recommended redline
14
15### Step 3: Risk Classification
16**CRITICAL**: Classify the overall agreement:
17- GREEN: Standard terms, approve with minor comments
18- YELLOW: Deviations require negotiation
19- RED: Significant issues, escalate to senior counsel
20
21### Step 4: Output
22Produce a structured review memo (see Output Format below).Do not leave the output format to chance. If you want a table, show the AI what the table looks like. If you want a memo with specific sections, define them.
Anthropic’s contract-review skill specifies a redline table format with columns for Clause, Current Language, Proposed Redline, Rationale, Priority, and Fallback position. Skala’s term-sheet-review skill defines a complete output template:
1## Output Format
2
3Produce a review memo with the following structure:
4
5### Summary
6- Agreement type and parties
7- Overall risk rating (GREEN / YELLOW / RED)
8- Top 3 issues requiring attention
9
10### Clause Analysis Table
11
12| Clause | Current Term | Market Standard | Rating | Recommendation |
13|--------|--------------|-----------------|--------|----------------|
14| ... | ... | ... | ... | ... |
15
16### Detailed Findings
17For each YELLOW or RED item, provide:
18- Why this deviates from market standard
19- Business impact
20- Suggested redline language
21- Fallback position if counterparty rejectsThis is where skills truly outperform prompts. Instead of trying to cram everything into one file, put detailed domain knowledge into separate reference files and point to them from your instructions.
Skala’s term-sheet-review skill keeps a references/market-standards.md file with current market data (2024–2025 benchmarks from Cooley, Carta, and NVCA) and a references/clause-analysis.md with 500 lines of detailed clause guidance. The main SKILL.md stays lean and focused on the workflow, pulling in references only when the AI needs them.
1## Reference Materials
2
3For detailed clause analysis guidance, consult:
4- `references/clause-analysis.md` — clause-by-clause standards
5- `references/market-standards.md` — current market benchmarks
6
7For template documents:
8- `templates/mutual-nda.docx` — firm standard mutual NDA
9- `templates/unilateral-nda.docx` — firm standard unilateral NDAShow the AI what good output looks like. Skala’s client-alert-drafting skill includes seven annotated examples from top-tier law firms, with commentary on what makes each one effective. Even two or three examples can dramatically improve output quality.
Tell the AI what the skill does not cover. Jamie Tso’s NDA review skill explicitly states it handles unilateral commercial NDAs only and flags mutual NDAs as out of scope. Skala’s term-sheet-review skill redirects Series B+ deals to outside counsel.
1## Scope
2
3This skill covers:
4- Pre-seed through Series A term sheets
5- Standard VC financing terms
6
7This skill does NOT cover:
8- Series B and later rounds (recommend outside counsel)
9- Debt financing or convertible notes
10- Non-US jurisdictions (note: add jurisdiction-specific
11 reference files to expand coverage)Let us put these patterns together and build a complete skill for reviewing VC term sheets — one of the most common tasks for startup lawyers and a perfect candidate for packaging as a skill.
A term sheet review needs more than just instructions. The AI needs to know what market standard looks like at different stages, and it needs detailed guidance on how to analyze each clause. That means reference files from day one.
1term-sheet-review/
2├── SKILL.md
3├── references/
4│ ├── clause-analysis.md
5│ └── market-standards.mdThe description needs to be specific about stages, user roles, and trigger phrases that a founder or investor might use.
1---
2name: term-sheet-review
3description: Review VC term sheets for pre-seed, seed, and
4Series A rounds. Analyzes each clause from investor or startup
5perspective, identifies investor-friendly vs. founder-friendly
6terms, flags deviations from market standards, and provides
7negotiation guidance. Use when reviewing any VC term sheet,
8evaluating investment terms, or preparing for funding
9negotiations. Triggers on term sheet, VC financing, Series A,
10seed round, liquidation preference, anti-dilution, protective
11provisions.
12---Notice the trigger words at the end: “term sheet,” “VC financing,” “Series A,” “liquidation preference.” These are the exact phrases a founder or investor would use when asking for help, and they help the AI decide to load this skill rather than a generic contract review.
Here is Skala’s actual term-sheet-review skill, condensed to show the key structural decisions:
1# VC Term Sheet Review
2
3> **Important**: This skill is provided for informational and
4> educational purposes only and does not constitute legal advice.
5> Always consult with a licensed attorney for advice on specific
6> legal matters.
7
8## Workflow
9
101. **Ask user role**: Investor or Startup founder?
112. **Identify investment stage**: Pre-seed, Seed, Series A,
12 or Series B+
133. **Extract and analyze each clause** against market standards
144. **Rate each term**: Investor-friendly, Founder-friendly,
15 or Market standard
165. **Provide tailored recommendations** based on user’s role
176. **Generate summary** with key negotiation points
18
19## Initial Questions
20
21Before reviewing a term sheet, ask the user:
221. Are you the INVESTOR or the STARTUP in this transaction?
232. What stage is this financing? (Pre-seed / Seed / Series A)
24
25**Series B+ handling**: If the term sheet is for Series B or
26later, note that the skill’s expertise is primarily pre-seed
27through Series A. Recommend also consulting experienced
28later-stage counsel, then proceed if requested.
29
30## Key Clauses to Review
31
32Analyze these 15 clauses in order:
33
34### Economics
351. Valuation (pre-money, post-money, option pool)
362. Liquidation Preference (multiple, participating vs non-)
373. Dividends (cumulative vs non-cumulative, rate)
384. Anti-dilution (full ratchet vs weighted average)
395. Pay-to-play
40
41### Control
426. Board Composition (seats, observer rights)
437. Protective Provisions (veto rights)
448. Drag-along Rights
459. Voting Rights
46
47### Other Rights
4810. Pro-rata Rights
4911. Information Rights
5012. Registration Rights
5113. Right of First Refusal / Co-sale
5214. Founder Vesting
5315. No-shop Period
54
55## Clause Analysis Framework
56
57For each clause, provide:
58- **Current term**: What the term sheet says
59- **Market standard**: Typical for this stage
60 (see references/market-standards.md)
61- **Rating**: Investor-friendly / Founder-friendly /
62 Market standard
63- **Impact**: How this affects the user (based on role)
64- **Negotiation tip**: Specific guidance for user’s position
65
66## Output Format
67
68## Term Sheet Review Summary
69
70**Company**: [Name]
71**Round**: [Stage]
72**Reviewing as**: [Investor / Startup]
73
74## Overall Assessment
75[2-3 sentence summary]
76
77## Clause-by-Clause Analysis
78[For each of the 15 clauses]
79
80## Key Negotiation Points
811. [Most important issue]
822. [Second priority]
833. [Third priority]
84
85## Red Flags
86- [Terms significantly outside market norms]
87
88## Summary Table
89| Clause | Rating | Priority to Negotiate |
90|--------|--------|-----------------------|Two things to notice. First, the skill changes its behavior based on who is asking — a founder gets different negotiation tips than an investor reviewing the same clause. Second, the 15-clause checklist ensures nothing gets missed, even if the user only asked about one specific term. The AI reviews everything, then highlights what matters most for this user.
This is where the skill goes from good to genuinely useful. The SKILL.md stays focused on the workflow, but the reference files carry the real domain knowledge.
references/clause-analysis.md — A detailed guide for each of the 15 clause types. For every clause, include: what it means, why it matters, what the investor perspective looks like, what the startup perspective looks like, common variations, red flags, and suggested negotiation language. Skala’s version runs to about 500 lines.
references/market-standards.md — Quick-reference tables organized by stage. What does a typical pre-seed liquidation preference look like versus a Series A? What is the standard anti-dilution provision at each stage? Include the source of your data (Cooley, Carta, NVCA, or your own deal experience) and the date range so users know how current the benchmarks are.
These reference files are what make the skill dramatically better than a raw AI prompt. Without them, the AI draws on its general training data, which may be outdated or generic. With them, it draws on your curated, current, practice-specific knowledge.
Upload an actual term sheet and run the skill. Check whether it correctly identifies the stage, asks the right initial questions, catches the 2x participating liquidation preference buried in section 3, and rates the anti-dilution clause appropriately for the stage. If the market standards in the output feel generic, your market-standards.md needs more detail. If the negotiation tips are vague, your clause-analysis.md needs sharper guidance.
Iterate until the output is something you would be comfortable handing to a client as a first-pass analysis.
Anthropic published its own legal plugin as open source on GitHub. It contains six skills that form a complete in-house legal workflow: contract-review, nda-triage, compliance, legal-risk-assessment, meeting-briefing, and canned-responses. Studying these reveals several patterns worth adopting.
Playbook-driven architecture. Rather than hardcoding legal positions into the skill itself, Anthropic’s contract-review skill loads positions from a separate playbook configuration file. The playbook defines standard positions, acceptable ranges, and escalation triggers for each clause type. This means the same skill works for different organizations — you just swap the playbook.
Color-coded classification. All six skills use the same GREEN/YELLOW/RED system for risk classification. GREEN means standard, approve. YELLOW means deviations exist, negotiate or review. RED means significant issues, escalate. This consistency means users learn the system once and apply it everywhere.
Escalation frameworks. Each skill includes clear rules for when to involve a human. The legal-risk-assessment skill uses a 5x5 severity-by-likelihood matrix that produces a numerical risk score (1-25). Scores above 15 trigger mandatory escalation to C-suite or board level. This removes ambiguity about when AI analysis is sufficient versus when a senior lawyer needs to step in.
Template-based responses. The canned-responses skill manages seven categories of templated replies — from data subject requests to litigation holds to vendor inquiries. Each template includes “Use When” and “Do NOT Use When” conditions, making it clear when a templated response is appropriate and when the situation requires individualized attention.
Cross-skill integration. The skills are designed to work as a system. A contract review might flag a data protection issue that triggers the compliance skill. An NDA triage might surface risks that feed into the risk-assessment skill. A deal meeting might require a briefing that pulls from all of the above.
You can install these skills yourself to study them:
claude plugins add knowledge-work-plugins/legalOr browse the source at github.com/anthropics/knowledge-work-plugins/legal.
Building a skill is half the work. Testing is the other half.
Start by iterating on a single task. Do not try to test everything at once. Upload one real NDA and run your skill against it. Look at the output. Is the risk classification correct? Did it catch the missing carveout in clause 4? Did it miss the non-solicitation buried in section 7?
Anthropic recommends testing in three areas:
Triggering tests. Does the skill activate when it should? Try different phrasings: “Review this NDA,” “Can you check this confidentiality agreement,” “What are the issues with this NDA?” Also test that it does not trigger on unrelated requests.
Functional tests. Does the skill produce correct output? Run it against documents with known issues and check whether it catches them. Run it against clean documents and verify it does not flag false positives.
Performance comparison. Run the same task with and without the skill enabled. The skill version should be faster (fewer back-and-forth messages), more consistent (same structure every time), and more thorough (catches issues the unsupported AI would miss).
When something does not work, refine. Skills are living documents. Add detail where the AI was too vague. Add explicit instructions where it went off track. Add reference files where it lacked domain knowledge.
Once your skill is ready, you can keep it to yourself, share within the organization or make it open-source.
If you want to build your first legal skill, here is a simple path:
You do not need to build something as comprehensive as Anthropic’s legal plugin on day one. Start with a simple skill that solves one problem well. You can always layer in complexity — reference files, templates, scripts — as you learn what works.
The legal profession runs on structured knowledge: playbooks, checklists, precedents, and standard forms. Skills are simply the format for making that knowledge work with AI. If you have been doing legal work for any length of time, you already have the raw material. The skill just gives it a shape the machine can follow.