A contract returned with twenty-something changes from the client used to mean an hour of manual review for the senior team member who knew which changes mattered. With a SharePoint AI Skill, the same review now runs in under a minute and the output is the same shape every time. One person writes the SOP. The whole team runs it.
This is the walkthrough of the contract review Skill I built for a financial services client. Twelve minutes of video showing the full build, then the live run flagging 24 changes ordered by business impact.
The problem the Skill solves
The starting state is one most commercial and legal teams will recognise.
A contract goes out to a client based on a standard template. The client makes adjustments and sends it back. Someone on the team has to read both versions side by side, identify every change, decide which changes matter, and produce a summary the deal team can act on.
The manual version takes 45 to 90 minutes per contract. The output quality depends entirely on who does the review. The senior reviewer catches the clauses that matter; less experienced reviewers focus on cosmetic changes and miss the structural ones. Throughput is the bottleneck on closing deals.
The contract review Skill captures the senior reviewer's process in 60 lines of Markdown. Same review, in under a minute, with the senior reviewer's standard baked in.
What the Skill does, step by step
The SKILL.md file defines six things in plain Markdown.
When to use. Trigger phrases like "review this contract", "gaps analysis", "what changed". Copilot in SharePoint auto-loads the Skill when these phrases appear in a chat on the site.
Inputs. The base contract path (a fixed location in the documents library, defined inside the Skill so the user does not have to specify it) and one or more returned contracts selected in chat by the user.
Steps. Load the base contract. Load each returned contract. For each one, compare clause by clause. Flag every change in a table with three columns: clause, change summary, business impact (low/medium/high). Order the table by impact descending. Surface any missing mandatory clauses (force majeure, termination, governing law) at the top.
Output. A Markdown table with the columns above, followed by a one-line summary of total changes flagged and the count by impact band.
Rules. Plain English in the change summary; no legalese. Never modify the contracts; the Skill is read-only. If a returned contract cannot be parsed, flag it and skip; do not fail the whole batch.
That is the entire Skill. About 60 lines of Markdown. The pattern is intentionally simple so the team can maintain it without specialist tooling.
The live demo: 24 changes flagged
In the video, the Skill runs on a real returned contract. The output is a priority-ordered table.
The high-impact changes surface at the top. The Skill identifies that the indemnity clause has been narrowed, the termination notice has been extended from 30 days to 90 days, and the governing law has been changed to a different jurisdiction. Three clauses, three high-impact flags, surfaced before any of the cosmetic changes.
The medium-impact changes follow. Payment terms, liability caps, IP assignment.
The low-impact changes are at the bottom. Defined terms reordered, formatting adjustments, typographical corrections.
Total: 24 changes flagged in around 90 seconds. The deal team gets the priority list ordered exactly the way the senior reviewer would have produced it, in 1/45th of the time.
Why the Skill pattern beats manual review
Three reasons it works at scale.
Consistency across reviewers. Without the Skill, the same returned contract reviewed by three different team members produces three different outputs. Different terminology, different structure, different judgement calls on what counts as high impact. With the Skill, the impact bands are defined in the file, so every run uses the same rubric.
Senior judgement, encoded. The senior reviewer's instinct for which clauses matter is now in the Skill's impact-band definitions. New team members do not have to absorb that judgement through years of contract reviews. They invoke the Skill and the judgement applies.
Reuse without rewriting. When the standard changes (a new mandatory clause is added, the company's risk appetite shifts on a particular term), the Skill file changes once. Every future run picks up the new standard. No retraining required.
What it cost to build
About a half-day of work, split across two phases.
Phase one, two hours. Map the senior reviewer's process. What clauses do you always check? What makes a change high impact versus low? What is the output format the deal team actually uses?
This is the work that should happen anyway when an organisation tries to scale its contract review process. The Skill just gives you a permanent home for the answers.
Phase two, ninety minutes. Write the SKILL.md file. Copy the structure from the Skills deep-dive guide. Plug in the impact-band rules and the mandatory-clause checks. Save to /Agent Assets/Skills/contract-review/SKILL.md.
Phase three, an hour, spread across the first three live runs. Iterate on the rules as the team finds edge cases. The first run will produce 80% of the right output. The next two runs let you tighten the rules and clarify the impact-band definitions.
Total elapsed: about half a working day. Payback: the first time a team member who is not the senior reviewer uses the Skill and produces output the deal team can act on without senior sign-off.
Permissions and governance
Worth being explicit about because contracts are often sensitive.
The Skill runs with the executing user's permissions. A user can only invoke the Skill on contracts they have permission to read. If a contract is in a restricted folder, the user without access cannot use the Skill to summarise it; the Skill returns nothing for that contract.
Sensitivity labels apply unchanged. A contract labelled Highly Confidential remains Highly Confidential through the review process. The output of the Skill inherits the appropriate label automatically.
The Skill itself is a file. It has the same audit trail as any document on the site. Microsoft Purview audit logs include every invocation of the Skill alongside other AI in SharePoint activity. Governance teams can see who ran which Skill on which contract and when.
Adapting the pattern to your team
The contract review Skill is a worked example. The same pattern works for any document review where you compare a base to a returned version.
Vendor contracts. Same shape, swap the impact-band rules to match your procurement criteria.
NDAs. Tighter check list, focus on confidentiality scope, term, and exclusions.
Statements of work. Compare against the master service agreement; flag deviations from agreed deliverables, pricing, and timelines.
Policy approvals. Compare the proposed policy against the current approved version; flag changes that need committee review.
Proposal reviews. Apply your proposal standards (voice, structure, mandatory inclusions) to a draft and flag where it deviates.
In every case the SKILL.md file is the same general shape. The work is in defining the impact bands and mandatory checks for your specific use case.
What to do this week
If your team reviews contracts (or any structured documents) repeatedly and the quality varies by reviewer, three actions.
-
Watch the video above if you have not already. Twelve minutes covers the full build and the live demo.
-
Read the SharePoint AI Skills deep-dive for the anatomy of a SKILL.md file and the boundaries Skills operate within.
-
Write the impact-band rules for your team. Not the Skill, just the rules. What makes a change high impact versus low? What clauses are mandatory? Get this in writing first. The Skill is downstream of the answer to those questions.
Then ask Copilot in SharePoint to write the Skill for you. The natural-language path described in the Skills deep-dive lets you describe the Skill in chat; AI in SharePoint generates the SKILL.md file ready for review.
If your team wants to build three Skills in your tenant in a day rather than spreading the work across weeks, the Copilot in SharePoint Immersive is a one-day session where we build them together. Contract review is one of the most common Skills I run with clients in that session.
Before any of that, your site benefits from a SharePoint.md context file. The contract review Skill works better when AI in SharePoint already knows the site's library structure, your house style, and your voice rules. The template is the fastest way to get that in place.
