Tag: microsoft-word

  • Document Automation with Claude and Microsoft Word: A Walkthrough for Small Firms

    Document Automation with Claude and Microsoft Word: A Walkthrough for Small Firms

    This workflow turns a single Word clause library and a Claude prompt template into a repeatable drafting machine — cutting 10 to 20 minutes off every engagement letter, NDA, demand letter, and fee agreement you produce.

    The workflow is built for solo attorneys and firms of two to ten lawyers who are drafting the same five to eight document types repeatedly and doing it mostly by hand. You don’t need a document automation platform, a monthly SaaS subscription, or a developer. You need a Claude account (the Pro tier works fine), Microsoft Word, and about two hours to set it up the first time. After that, each document runs in under five minutes of AI time, plus your review pass.

    What you’ll need

    • Claude Pro ($20/month at claude.ai) — the claude.ai web interface is sufficient; API access is optional but speeds things up if you want to go further later.
    • Microsoft Word — desktop version, Microsoft 365 or a perpetual license. The workflow works with the web version but the macro/style features described below require the desktop app.
    • One master clause library document — a single .docx file you’ll build in Step 1.
    • A plain-text intake form — a short list of matter variables (client name, jurisdiction, date, deal type, etc.) you fill out before each run. A Word table or a Notepad file both work.

    Step 1: Build your clause library in one Word document

    The clause library is the foundation. Without it, Claude drafts from general training data — which produces serviceable but generic language you’ll spend time rewriting anyway. With it, Claude assembles from clauses you’ve already vetted.

    Create a new Word document called CLAUSE_LIBRARY_MASTER.docx. Organize it with Word Heading 1 styles for document type and Heading 2 for each clause. A minimal starting library looks like this:

    • Engagement Letters: scope of representation, fee structure (hourly / flat / contingency variants), billing cycle and invoice terms, communication expectations, termination by client, termination by firm, conflict waiver carve-out, file retention notice.
    • NDAs: definition of confidential information, exclusions, permitted disclosures, term and termination, return/destruction of materials, remedies clause, governing law placeholder.
    • Demand Letters: opening statement of representation, factual background placeholder, legal basis paragraph (tort / contract / statutory variants), demand and deadline paragraph, reservation of rights, closing.
    • Fee Agreements: scope reference, rate schedule, retainer mechanics, billing increment, late payment, lien notice, dispute resolution over fees.

    Each clause entry should be the actual text you’d use — not a description of it. Pull from your best current templates. Flag jurisdiction-specific language with a bracketed tag like [JURISDICTION: CA only] or [JURISDICTION: TX only]. That tag will matter in Step 3.

    Keep every clause under 150 words. Long multi-part clauses should be split. When you paste library content into a Claude prompt later, shorter chunks give the model cleaner assembly instructions.

    Step 2: Create your intake variable sheet

    Before you run any prompt, fill out a matter intake sheet. This is just a list of variables. Keep it in a Word table at the top of each new matter folder, or in a pinned Notepad file you overwrite each time. The fields below cover all four document types — you’ll only use the relevant subset per document run.

    • CLIENT_NAME
    • CLIENT_ENTITY_TYPE (individual / LLC / corporation / etc.)
    • MATTER_TYPE (engagement letter / NDA / demand letter / fee agreement)
    • JURISDICTION (state)
    • GOVERNING_LAW_STATE (if different from jurisdiction)
    • ATTORNEY_NAME
    • FIRM_NAME
    • DATE
    • FEE_STRUCTURE (hourly at $X / flat fee of $X / contingency at X%)
    • BILLING_INCREMENT (e.g., 0.1 hour)
    • RETAINER_AMOUNT
    • OPPOSING_PARTY (demand letters only)
    • CLAIM_SUMMARY (demand letters only — two to four sentences, plain language)
    • DEMAND_AMOUNT (demand letters only)
    • RESPONSE_DEADLINE (demand letters only)
    • NDA_PARTIES (both party names and entity types)
    • NDA_PURPOSE (one sentence)
    • NDA_TERM (months/years)
    • SPECIAL_INSTRUCTIONS (anything that overrides standard clauses)

    Filling this out takes two to three minutes. That time investment is what makes the Claude output usable on the first pass rather than the third.

    Close-up detail shot of hands resting on a mechanical keyboard, a Word document visible on screen as soft abstract white

    Step 3: The Claude prompt template

    This is the core of the workflow. The prompt does three things: it tells Claude what document to produce, it feeds in your vetted clause library text, and it tells Claude exactly how to handle anything the library doesn’t cover. Run this at claude.ai with Claude 3.5 Sonnet (the default model as of mid-2025). Paste the filled-in intake variables where indicated.

    You are a document drafting assistant for a law firm. Your job is to assemble a [MATTER_TYPE] using the clause library I provide below. Follow these rules exactly:

1. Use ONLY the clauses I provide in the CLAUSE LIBRARY section. Do not invent new legal language.
2. Where a clause contains a [JURISDICTION: XX only] tag, include that clause ONLY if the jurisdiction in the matter variables matches. Otherwise, omit it and note the omission in brackets at the end of the document.
3. Wherever you see a variable in ALL_CAPS in the clause text (e.g., CLIENT_NAME, FEE_STRUCTURE), replace it with the corresponding value from the MATTER VARIABLES section below.
4. If the clause library does not contain a clause needed for this document type, insert a bracketed placeholder: [CLAUSE NEEDED: describe what's missing] — do not write the clause yourself.
5. Output the assembled document in clean paragraph form, ready to paste into Word. Use clear section headings. Do not include commentary, footnotes, or explanations in the body — those go in a separate DRAFTING NOTES section at the end.
6. After the document body, include a DRAFTING NOTES section listing: (a) any jurisdiction-specific clauses that were omitted because the library didn't have a match, (b) any [CLAUSE NEEDED] placeholders you inserted, (c) any variable fields you could not fill because the intake form was incomplete.

---

MATTER VARIABLES:
CLIENT_NAME: [paste value]
CLIENT_ENTITY_TYPE: [paste value]
MATTER_TYPE: [paste value]
JURISDICTION: [paste value]
GOVERNING_LAW_STATE: [paste value]
ATTORNEY_NAME: [paste value]
FIRM_NAME: [paste value]
DATE: [paste value]
FEE_STRUCTURE: [paste value]
BILLING_INCREMENT: [paste value]
RETAINER_AMOUNT: [paste value]
[add or remove fields as relevant to this document type]
SPECIAL_INSTRUCTIONS: [paste value or "none"]

---

CLAUSE LIBRARY:
[Paste the relevant section(s) of your CLAUSE_LIBRARY_MASTER.docx here. For an engagement letter, paste the Engagement Letters section. For an NDA, paste the NDA section. Keep the Heading 2 labels so Claude can reference them.]

---

Produce the [MATTER_TYPE] now.

    A few notes on this prompt. The “do not invent new legal language” instruction is the most important line. Without it, Claude will helpfully fill gaps with plausible-sounding clauses that you haven’t reviewed. The bracketed placeholder approach — [CLAUSE NEEDED: describe what's missing] — surfaces those gaps cleanly so your review pass catches them immediately.

    The DRAFTING NOTES section at the end is genuinely useful. It acts as a checklist. If Claude flags “omitted retainer lien notice — no California version in library,” that’s your signal to add a California version to the clause library before the next matter.

    Step 4: Move the output into Word and run your review pass

    Claude outputs clean plain text. Copy the document body (everything above the DRAFTING NOTES section) and paste it into a new Word document. Use Paste Special → Keep Text Only, then apply your firm’s styles. This takes about 90 seconds.

    If your firm uses a branded Word template (.dotx file), open that template first, paste into it, and your headers, fonts, and margins apply automatically. For firms that haven’t built a .dotx template yet: build one. It takes an hour once and saves formatting time on every document you produce.

    Your review pass has three specific jobs. First, read every clause that carries a jurisdiction tag and confirm it’s correct for this matter — Claude can mis-match these if your intake variables are ambiguous. Second, read every line that replaced a variable and confirm the substitution makes grammatical and substantive sense. “The firm shall bill CLIENT_NAME at an hourly rate” assembles correctly; “The client, a LLC, agrees” does not and needs a quick fix. Third, work through Claude’s DRAFTING NOTES checklist and resolve every item before the document leaves your desk.

    Do not skip the review pass. This workflow does not produce final documents. It produces reviewed-ready drafts — which is still a meaningful time compression compared to starting from scratch or hunting through old files for the right template version.

    Step 5: Version control without extra software

    Version control for this workflow is low-tech by design. In your matter folder, save each Claude-generated draft with a filename convention: CLIENTNAME_DOCTYPE_v1_YYYYMMDD.docx. When you complete your review pass and make edits, save as v1-reviewed. When the document goes out, save as v1-final. If you revise after client feedback: v2.

    Also save the prompt you ran — paste it into a _PROMPT_LOG.txt file in the same folder. This takes ten seconds and gives you a complete record of what input generated what output. If you ever need to explain why a clause appeared in a document, you have the paper trail.

    For the clause library itself, treat it like source code. Save a dated backup whenever you add or change a clause: CLAUSE_LIBRARY_MASTER_20250610.docx. Keep the last three versions. You’ll want to know what the library looked like when you drafted a document six months ago.

    Where this breaks

    The single biggest failure mode is jurisdiction-specific clause gaps. Claude will follow the instruction to omit unmatched clauses and flag them — but only if your library tagged them correctly in the first place. If you built the library from California templates and you’re running a Texas matter, Claude may not know that what it’s assembling is California-only language unless you tagged it. Starting with a 50-state scope is unrealistic. Start with your primary jurisdiction and explicitly mark everything else as out-of-scope until you’ve added it.

    Variable substitution breaks on edge cases. A client who is a single-member LLC doing business under a DBA will confuse a simple variable replacement in ways you’ll catch only on review. Entities with long names break sentence flow. Joint representation (two clients, one engagement letter) requires a clause the basic library probably doesn’t handle. Build variants for those scenarios rather than expecting the prompt to figure them out.

    The prompt length has a ceiling. Claude 3.5 Sonnet handles a context window large enough for this workflow comfortably, but if you paste an entire 40-clause library plus a long intake form, output quality starts to slip — Claude may skip clauses or truncate the DRAFTING NOTES. Keep each library section to the clauses actually relevant to the document type you’re drafting. Don’t paste the whole library for an NDA run.

    Copy-paste friction is real. This workflow is faster than starting from scratch, but it’s not as fast as a purpose-built automation tool like HotDocs or Documate. If you’re producing more than 30 templated documents per month, the manual copy-paste steps add up and you should evaluate a proper document assembly platform instead. This workflow is the right fit for firms producing five to twenty templated documents per month who don’t want to pay platform fees or manage a separate system.

    Finally: Claude hallucinates. It does so less when constrained to a provided clause library, but it can still produce grammatically smooth sentences that say something slightly different from what your clause says. The review pass is not optional.

    What this saves you

    For a straightforward engagement letter — one client, one matter type, your primary jurisdiction — expect to spend two to three minutes filling out the intake form, one minute running the prompt, and five to eight minutes on the review pass. That’s under twelve minutes total, compared to a realistic twenty-five to thirty-five minutes pulling an old template, editing it, catching holdover text from the prior client, and formatting it correctly. The savings are in the middle: no hunting for the right old file, no manually replacing every instance of the prior client’s name, no re-applying styles.

    Demand letters save the most time because the factual background section — which you write yourself in the intake form as a plain-language summary — feeds directly into a structured output, replacing the blank-page problem. NDA runs are the fastest because the clause count is low and variable substitution is clean. Fee agreements run close to engagement letters in time.

    Over a week of ten to fifteen templated documents, the workflow realistically returns ninety minutes to two hours. That’s not dramatic. It’s also not nothing — it’s a full billing hour or more, every week, recovered from administrative drafting.

    The clause library also has a side benefit that doesn’t show up in time savings: it forces you to standardize. Firms that run this workflow for two months typically discover they had four slightly different versions of their termination clause floating across old templates. Consolidating them into the library is the kind of housekeeping that improves every document going forward, not just the ones produced by this workflow.

    Start with one document type, build out the library section for it, and run ten matters through it before you add the next type. The setup investment is real; spread it out and you’ll actually finish it.

    Related reading

  • Spellbook for Solo Lawyers: A Two-Week Test of the AI Contract Review Tool

    Spellbook for Solo Lawyers: A Two-Week Test of the AI Contract Review Tool

    Spellbook handles routine NDA and MSA review faster than doing it by hand — but throw a heavily-redlined draft or an exhibit-heavy agreement at it and the wheels come off.

    Spellbook is a Microsoft Word add-in that reads your contract, flags clause gaps, suggests redlines, and explains what it’s flagging in plain language. It’s built on GPT-4-class models and priced for law firms, not enterprise procurement teams. I ran it for two weeks on a mix of NDAs, MSAs, and SOWs — the bread-and-butter of a transactional solo — to find out whether it earns the monthly fee or just performs well in demos. The short answer: it earns it if you review contracts regularly. It doesn’t if you don’t.

    What It Does

    Spellbook lives in a sidebar inside Microsoft Word. You open a contract, open the sidebar, and Spellbook reads the document. From there it does three things: it flags clauses that are unusual or missing, it offers suggested language to replace or strengthen those clauses, and it answers questions about the document in a chat interface. All of this happens without leaving Word.

    The clause-flagging is the core feature and it’s genuinely good on clean drafts. On a standard mutual NDA, Spellbook caught a missing residuals clause, flagged an unusually broad definition of “Confidential Information” that lacked a standard carve-out for publicly available information, and noted that the term “Affiliate” was used twice but never defined. That’s exactly the kind of boilerplate gap that’s easy to miss on a Friday afternoon, and catching it took about forty seconds.

    The redline suggestion feature works the same way: click a flagged clause, and Spellbook offers replacement language. The suggestions are templated but adjustable — you can tell it “make this more favorable to my client, who is the vendor” and it rewrites accordingly. The quality is good enough to use as a first draft, not good enough to accept without reading.

    The chat interface lets you ask document-specific questions: “Does this agreement include an auto-renewal clause?” or “What’s the limitation of liability cap?” It pulls answers from the actual document text, not from general knowledge. On clean contracts, this was accurate. On contracts longer than about 30 pages, it started missing things — more on that below.

    Spellbook also runs what it calls a “playbook” review: you can load a standard set of preferred positions and it checks the contract against those positions automatically. Setting up a playbook takes some initial investment, but once it’s configured, it runs on every new document without extra prompting.

    Where It Actually Fits

    The sweet spot is a solo transactional attorney — or a small firm where one or two attorneys handle a steady flow of commercial contracts — who reviews NDAs, MSAs, SOWs, or vendor agreements multiple times a week. If you’re looking at five or more contracts a week, Spellbook pays for itself in time saved on first-pass review. The clause-flagging catches enough real issues fast enough that it shortens the first read meaningfully.

    For NDAs specifically, Spellbook is close to ideal. NDAs are structurally consistent enough that the model’s training shows: it knows what should be there, flags what isn’t, and the suggested language is close to usable. I ran eight NDAs through it over two weeks and it found something worth flagging in seven of them. Most of those were things I’d have caught anyway — but Spellbook caught them in the first sixty seconds, before I’d done my own read.

    MSAs with clean structure — a base agreement and one or two order forms, no exhibits attached — also work well. The model handles defined-term tracking better than I expected. It flagged two instances in one MSA where “Services” was used in a section that defined the scope, but the exhibit was supposed to govern scope instead, creating a potential conflict. Useful catch.

    The playbook feature fits well for solos who represent the same side of a transaction repeatedly — always the vendor, always the SaaS company, always the contractor. Load your preferred positions once and Spellbook runs those checks automatically. That saves real time compared to building a mental checklist every time.

    Practice areas beyond transactional commercial work get thinner. Employment agreements, commercial leases, and IP assignments work reasonably well because the structures are common enough that the model recognizes them. Anything more specialized — complex finance documents, healthcare agreements with regulatory-specific clauses — showed less confident suggestions and more generic flags.

    Close detail shot of hands resting on a mechanical keyboard, a printed contract visible on the desk surface to the right

    Where It Breaks

    Heavily-redlined drafts broke it for me consistently. When a contract has three or four rounds of tracked changes from multiple parties still embedded — all visible in Word — Spellbook gets confused about which version of the text to analyze. I ran one MSA that had been through two rounds of opposing counsel redlines and Spellbook flagged a clause as missing that was actually present in an accepted redline two paragraphs up. It was reading the document as if the redline layer didn’t exist. This is a real workflow problem because most contracts that need careful review are exactly the ones with heavy markup.

    The workaround is to accept all changes, save a clean copy, and run Spellbook on that. That works, but it adds a manual step and means you’re not reviewing the document in the state your client actually sent or received it.

    Exhibit-heavy MSAs were the other consistent failure mode. When an MSA had three or four attached exhibits — a Statement of Work template, a Data Processing Addendum, a Security Exhibit — Spellbook would analyze the base agreement without meaningfully integrating the exhibit content. It flagged “no data processing terms found” in one agreement where the DPA was a separate exhibit on the next page. The tool is analyzing the document section it can see, not the agreement as a whole when exhibits are substantively separate files or appendices.

    Long documents slow the suggestions down noticeably. Anything over 25-30 pages and the chat answers started lagging by five to ten seconds. Not a dealbreaker, but noticeable when you’re moving fast.

    The suggested redline language is templated enough that it occasionally reads as generic. On one SOW, the suggested scope-limitation language was so standard it didn’t account for the specific services described in the document. I used it as a starting point and rewrote it in about two minutes, but “starting point” is the accurate description — not “finished clause.”

    Spellbook also requires Microsoft Word. If your firm runs on Google Docs or if opposing counsel sends PDFs that you work in natively, you’ll need to convert first. That friction is minor but real. There is no Google Docs version as of this writing.

    What It Costs and What You Get

    Spellbook’s pricing is seat-based and billed annually. As of mid-2025, a solo seat runs approximately $149 per month (billed annually at roughly $1,788 per year). That’s the standard tier, which includes unlimited document reviews, the clause-flagging and suggestion features, and the chat interface.

    The playbook feature — loading your own preferred positions and running them automatically — is included in the standard tier, not gated behind a higher plan. That’s worth noting because playbooks are what make the tool genuinely faster for a solo who handles repeat transaction types.

    There is a higher-tier plan (pricing available on request) that adds team collaboration features, admin controls, and usage analytics. For a true solo, the standard tier is the right tier. The team features add overhead you don’t need when you’re the only reviewer.

    Spellbook offers a free trial — 14 days as of this writing — and the trial is full-featured, not limited to toy documents. Running the trial on real matters from your current workload is the right way to evaluate it. Running it on sample contracts tells you almost nothing about whether it fits your practice.

    At $149 per month for a solo, the math is straightforward. If Spellbook saves you one hour of first-pass review per week and your effective hourly rate is $200 or above, it pays for itself in about two billable hours per month. If you review fewer than two or three contracts a week, the calculus gets harder.

    Verdict

    Use it if you’re a transactional solo or a small firm handling commercial contracts regularly — NDAs, MSAs, vendor agreements, SOWs — and you want a faster first-pass review without hiring a second set of eyes. The clause-flagging is accurate enough on clean drafts to save real time, and the playbook feature compounds that value once you’ve set it up for your standard transaction types.

    Skip it if you’re primarily a litigator, if your transactional work is occasional rather than routine, or if your practice runs on Google Docs. The Word dependency is a real constraint and the monthly cost doesn’t make sense below roughly two to three contract reviews per week.

    Wait six months if your typical workflow involves heavily-redlined multi-party drafts or exhibit-heavy agreements that run past 30 pages. Spellbook is aware of these limitations — the tracked-changes issue in particular is something the product team has acknowledged — but as of this writing those gaps are real enough to affect daily use on complex matters.

    Related reading