Tag: legal-drafting

  • 10 ChatGPT Prompts Every Solo Lawyer Should Save (Tested on Real Matters)

    10 ChatGPT Prompts Every Solo Lawyer Should Save (Tested on Real Matters)

    These ten prompts took me from blank page to usable first draft on actual client matters — intake calls, demand letters, deposition prep, and everything in between. Save them now; tweak the variables later.

    Every solo lawyer I talk to has the same complaint: too many tasks, not enough time, and AI tools that sound impressive until you actually try them on a real matter. The prompts below were built for ChatGPT (GPT-4o) and tested across family law, employment, and small-business transactional matters. They are not magic. They produce first drafts, not final work product. But a solid first draft that takes three minutes instead of forty-five minutes is the whole point.

    A few ground rules before you start. Never paste full client names, Social Security numbers, or identifying case details into a public AI tool. Use placeholders like [CLIENT], [OPPOSING PARTY], and [MATTER TYPE]. If your firm uses Microsoft Copilot or a privacy-partitioned ChatGPT Enterprise account, you have more flexibility — but check your bar’s current guidance on client data and AI tools before you do anything. These prompts work best as templates you adapt, not scripts you run verbatim.

    1. Intake Call Summary into a Structured Brief

    When to use it: Right after an intake call. You have rough notes or a transcript from a call-recording tool like Otter.ai or Fireflies. You need a clean, structured brief to open a new matter file.

    What to expect: A structured output with labeled sections — parties, key facts, potential claims, open questions, and recommended next steps. The model is good at pulling signal from messy notes. It will occasionally hallucinate a “fact” that wasn’t in your notes, so read it against your source before filing it anywhere.

    You are a legal assistant helping a solo attorney organize intake notes.
    
    Below are rough notes from a new client intake call. Convert them into a structured brief with these sections:
    1. Parties (client name placeholder, opposing party placeholder, any other relevant persons)
    2. Core Facts (bullet list, chronological where possible)
    3. Potential Claims or Issues (list only — do not evaluate likelihood)
    4. Documents Mentioned or Needed
    5. Open Questions for Follow-Up
    6. Suggested Next Steps
    
    Do not add facts not present in the notes. Flag anything unclear with [UNCLEAR].
    
    Intake notes:
    [PASTE YOUR NOTES HERE]

    Tweaks: Add a sixth section called “Conflicts Check Names” and ask the model to pull every person and entity name mentioned — that feeds directly into prompt #2. If you handle a specific practice area, add “Practice area: [AREA]” so the model can weight its issue-spotting accordingly.

    2. First-Pass Conflict Check from a Party List

    When to use it: You’ve got a new matter and a list of parties. You want a quick cross-reference against your existing client list before your conflicts-check software runs its full scan — or if you don’t have dedicated conflicts software.

    What to expect: The model will flag name matches, near-matches, and related entities. This is a first pass, not a complete conflicts check. Your malpractice carrier and bar rules require a real process — this prompt helps you surface obvious problems faster.

    You are a legal assistant running a first-pass conflicts check for a solo attorney.
    
    New matter parties:
    [LIST ALL PARTIES, ENTITIES, AND KEY PERSONS FROM THE NEW MATTER]
    
    Existing client and adverse party list:
    [PASTE YOUR CURRENT CLIENT/ADVERSE PARTY LIST — USE PLACEHOLDERS IF NEEDED]
    
    Tasks:
    1. Flag any exact name matches between the two lists.
    2. Flag any likely near-matches (similar names, abbreviations, DBAs).
    3. Flag any entities that share a name root with a listed party.
    4. List any names from the new matter that do NOT appear on the existing list (for your records).
    
    Format the output as a table with columns: New Matter Party | Match Found | Match Type | Notes.

    Tweaks: This prompt only works as well as the list you feed it. Keep a running CSV of client and adverse party names in a note or document you can paste quickly. If your existing list is long, break it into chunks — GPT-4o handles roughly 25,000 words of context, but accuracy degrades near the ceiling.

    3. Demand Letter Draft from a Fact Pattern

    When to use it: You have a settled fact pattern and a clear demand amount. You need a professional demand letter drafted before you spend thirty minutes staring at a blank template.

    What to expect: A complete letter with opening statement of representation, fact recitation, legal basis section (labeled as general — you’ll fill in controlling authority), demand, and deadline. The model writes competent prose. It will not cite your jurisdiction’s specific statutes correctly without prompting, so always check cites before sending.

    You are a legal assistant drafting a demand letter for a solo attorney.
    
    Facts:
    [SUMMARIZE THE CORE FACTS — WHO DID WHAT, WHEN, AND WHAT HARM RESULTED]
    
    Jurisdiction: [STATE]
    Practice area: [E.G., EMPLOYMENT / PERSONAL INJURY / CONTRACT]
    Demand amount: $[AMOUNT] or [DESCRIBE RELIEF SOUGHT]
    Response deadline: [NUMBER] days
    
    Draft a professional demand letter. Use formal tone. Include:
    - Opening paragraph identifying the attorney and client (use [ATTORNEY NAME] and [CLIENT] as placeholders)
    - Factual background section
    - Legal basis section — flag where jurisdiction-specific statutes or case law should be inserted with [INSERT AUTHORITY]
    - Clear statement of demand
    - Response deadline and consequence of non-response
    
    Do not invent legal citations. Use [INSERT AUTHORITY] wherever a cite is needed.

    Tweaks: Add “Tone: [firm but professional / aggressive / conciliatory]” to the prompt to shift the letter’s posture. For employment matters, add the employer’s size if known — it affects which statutes apply and the model will note that in the [INSERT AUTHORITY] placeholders.

    4. Deposition Outline from Case Documents

    When to use it: You have a deponent, a set of documents, and not enough time to build a line-by-line outline from scratch. Paste in the relevant excerpts — discovery responses, prior statements, key emails — and let the model draft your question framework.

    What to expect: A topical outline with suggested question areas, document tie-ins, and impeachment flags. The model is strong on organizing themes and weak on jurisdiction-specific deposition procedure. Expect to add foundation questions and objection-anticipation notes yourself.

    You are a legal assistant helping a solo attorney prepare for a deposition.
    
    Deponent: [ROLE — E.G., "Defendant employer's HR director" — no real names]
    Matter type: [E.G., wrongful termination / breach of contract]
    Key issues in dispute: [LIST 3-5 CORE DISPUTED FACTS OR LEGAL ELEMENTS]
    
    Documents provided (paste excerpts below):
    [PASTE RELEVANT EXCERPTS — REDACT IDENTIFYING INFO AS NEEDED]
    
    Create a deposition outline organized by topic. For each topic:
    1. State the goal of that topic section (what you are trying to establish or undermine)
    2. List 5-8 suggested open-ended questions
    3. Note any document the attorney should introduce during that section
    4. Flag any prior statements in the documents that could be used for impeachment
    
    Do not suggest legal strategy. Flag factual inconsistencies in the documents with [INCONSISTENCY NOTE].

    Tweaks: If you have a prior deposition transcript from the same witness in another matter, paste selected excerpts and add “Flag any statements inconsistent with the documents above.” The model handles cross-document comparison reasonably well within a single context window.

    Close-up of two hands resting on a slim laptop keyboard, a printed contract visible on the desk beside it as soft abstra

    5. Engagement Letter Customization

    When to use it: You have a master engagement letter template and need to adapt it for a specific matter type, fee arrangement, or client situation without rewriting the whole thing manually.

    What to expect: The model will insert the right variables, flag clauses that may not fit the matter type, and suggest additions you might have missed. It will not flag jurisdiction-specific requirements you haven’t told it about — you still need to know what your state bar requires in an engagement letter.

    You are a legal assistant helping a solo attorney customize an engagement letter.
    
    Base template:
    [PASTE YOUR ENGAGEMENT LETTER TEMPLATE]
    
    Matter details:
    - Matter type: [E.G., estate planning / civil litigation / business formation]
    - Fee arrangement: [E.G., flat fee $X / hourly at $X / contingency at X%]
    - Scope of representation: [DESCRIBE WHAT IS AND IS NOT INCLUDED]
    - Any special terms: [LIST ANY CLIENT-SPECIFIC ARRANGEMENTS]
    
    Tasks:
    1. Insert the matter-specific details into the appropriate places in the template.
    2. Flag any clauses in the template that may not fit this matter type with [REVIEW THIS CLAUSE].
    3. Suggest any standard clauses that appear to be missing for this matter type, labeled [SUGGESTED ADDITION].
    4. Do not change any clause language without flagging the change clearly.
    
    Output: The revised letter with all changes marked in [BRACKETS].

    Tweaks: Run this with Claude Sonnet 3.5 if you want more conservative, flag-heavy output — Claude tends to over-flag, which is actually useful for compliance review. GPT-4o tends to write more fluently but flag less aggressively.

    6. Chronology Builder from Emails and Notes

    When to use it: You have a pile of emails, text summaries, and scattered notes and need a clean timeline. Works for breach-of-contract disputes, employment matters, domestic cases — anywhere a clear sequence of events matters.

    What to expect: A date-ordered table or list with source attribution. The model is good at pulling dates and sequencing events. It will occasionally misread ambiguous date formats (MM/DD vs. DD/MM) — flag that in the prompt if your documents mix formats.

    You are a legal assistant building a factual chronology for a solo attorney.
    
    Below are excerpts from emails, notes, and documents related to a single matter. Extract every datable event and build a chronology.
    
    Output format: A table with columns — Date | Event Description | Source | Significance Flag
    
    Rules:
    - Use the exact date from the source if available. If only a month/year is given, note that.
    - If a date is ambiguous or inferred, mark it [INFERRED DATE].
    - Significance Flag: mark events as [KEY] if they appear directly relevant to the core dispute; mark [BACKGROUND] for context events.
    - Do not add events not supported by the source material.
    - If two events appear to conflict in the record, flag both with [CONFLICT].
    
    Source material:
    [PASTE EMAILS, NOTES, AND EXCERPTS HERE — REDACT IDENTIFYING INFO]

    Tweaks: For long document sets, run this in batches by time period and then ask the model to merge and de-duplicate the resulting tables. Ask it to “merge the following two chronology tables, removing duplicate entries and resolving conflicts where the same event appears twice with different dates.”

    7. Settlement Agreement Plain-Language Summary for the Client

    When to use it: You’ve negotiated a settlement and need to explain it to a client who is not a lawyer. You want a summary that covers what they’re agreeing to, what they’re giving up, and what happens next — without the legalese.

    What to expect: A clean, readable summary organized by what the client receives, what the client must do, what the client cannot do after signing, and key dates. The model handles plain-language conversion well. Do not send this summary to the client in place of the actual agreement — it’s a companion document you review with them.

    You are a legal assistant helping a solo attorney explain a settlement agreement to a client in plain language.
    
    Settlement agreement text:
    [PASTE THE SETTLEMENT AGREEMENT — REDACT NAMES IF NEEDED]
    
    Write a plain-language summary for the client. Use simple sentences. No legal jargon without a plain-English explanation in parentheses.
    
    Organize the summary into these sections:
    1. What You Are Getting (payments, actions, other relief)
    2. What You Must Do (release of claims, confidentiality obligations, other duties)
    3. What You Cannot Do After Signing (restrictions, non-disparagement, non-compete if applicable)
    4. Important Dates and Deadlines
    5. What Happens If Either Side Doesn't Follow Through
    
    End with a short paragraph reminding the client to ask their attorney any questions before signing.
    
    Do not interpret ambiguous clauses — flag them with [ASK YOUR ATTORNEY ABOUT THIS].

    Tweaks: Adjust reading level with “Write at a 7th-grade reading level” or “Write for a sophisticated business client.” The model handles both well. If the agreement is long, paste it in sections and ask for section-by-section summaries first, then ask for a consolidated summary.

    8. Interrogatory Response First Draft

    When to use it: Opposing counsel has served interrogatories. You have your client’s answers in rough form — notes from a call, a client-filled questionnaire, bullet points. You need a properly formatted first draft before you do the real lawyering.

    What to expect: Formally formatted responses with proper headers, general objections section, and individual responses. The model will draft objections only if you give it grounds — it won’t invent them. You will need to review every objection for jurisdictional validity and every substantive response for accuracy. This prompt saves formatting time, not judgment time.

    You are a legal assistant helping a solo attorney draft interrogatory responses.
    
    Jurisdiction: [STATE / FEDERAL — DISTRICT IF FEDERAL]
    Case type: [E.G., employment discrimination / breach of contract]
    
    Interrogatories served:
    [PASTE THE INTERROGATORIES]
    
    Client's rough answers (as provided — do not treat these as verified):
    [PASTE THE CLIENT'S NOTES OR QUESTIONNAIRE ANSWERS]
    
    Draft formal interrogatory responses. Follow this structure:
    - Standard caption and introduction (use [CASE CAPTION] placeholder)
    - General Objections section — include only objections supported by these grounds: [LIST ANY GROUNDS YOU WANT INCLUDED, E.G., "overbroad," "unduly burdensome," "attorney-client privilege"]
    - Individual responses keyed to each interrogatory number
    - Where the client's answer is incomplete, draft the response to reflect what was provided and add [ATTORNEY: CONFIRM/SUPPLEMENT]
    - Where no client answer was provided, write [NO RESPONSE PROVIDED — ATTORNEY ACTION REQUIRED]
    
    Do not add substantive information the client did not provide.

    Tweaks: If you want the model to draft privilege-specific objections, add the privilege basis and a brief description of what you’re protecting. Never let the model guess at privilege — it will get it wrong.

    9. Objection-Letter Style Review of Opposing Counsel Correspondence

    When to use it: Opposing counsel sent a letter with factual characterizations, legal positions, or demands. You want a structured breakdown before you respond — what they claimed, what’s disputable, what’s accurate, and what they may be setting up.

    What to expect: A point-by-point analysis of the letter’s claims, flagging factual assertions, legal conclusions, and rhetorical moves separately. This is a thinking tool, not a draft response. It’s genuinely useful for clearing your head before you pick up the phone or start typing.

    You are a legal assistant helping a solo attorney analyze a letter from opposing counsel.
    
    Letter from opposing counsel:
    [PASTE THE LETTER]
    
    Your client's matter context (brief summary only):
    [2-3 SENTENCES ON THE MATTER — NO PRIVILEGED DETAIL]
    
    Analyze the letter with the following breakdown:
    1. Factual Claims — List each factual assertion made in the letter. For each, note whether it appears accurate, disputable, or unverifiable based on the context provided.
    2. Legal Positions — Identify any legal conclusions or theories asserted. Flag these as [LEGAL POSITION — ATTORNEY REVIEW NEEDED].
    3. Implicit Threats or Posturing — Note any implied threats, deadlines, or strategic positioning.
    4. Demands — List all explicit demands, including response deadlines.
    5. Suggested Response Points — For each factual claim marked disputable, note what a response might address. Do not draft the response itself.
    
    Do not evaluate the legal merit of positions — flag them for attorney review.

    Tweaks: This prompt works well as a second pass after you’ve already read the letter yourself. Run it after forming your own initial reaction and compare the model’s breakdown to your instincts — the gaps are usually informative.

    10. End-of-Week Matter Status Email to a Client

    When to use it: Friday afternoon. You have five active matters and five clients who haven’t heard from you since Tuesday. You have notes on what happened this week. You need five short emails in twenty minutes.

    What to expect: A professional, warm, appropriately brief client update email. The model writes competent client-facing prose without the wooden formality of a form letter. You’ll still need to fact-check every line against your actual matter status — the model only knows what you tell it.

    You are a legal assistant helping a solo attorney write a client status update email.
    
    Matter context:
    - Matter type: [E.G., pending litigation / contract negotiation / estate plan]
    - Current stage: [E.G., discovery / drafting / awaiting opposing party response]
    - What happened this week: [BRIEF BULLET POINTS]
    - What is happening next: [NEXT 1-2 STEPS]
    - Any action needed from client: [YES/NO — IF YES, DESCRIBE]
    - Tone: [PROFESSIONAL AND WARM / FORMAL / CASUAL — CLIENT'S PREFERENCE]
    
    Write a brief client update email (150-250 words). 
    - Address the client as [CLIENT FIRST NAME].
    - Sign as [ATTORNEY NAME].
    - Do not include specific dollar amounts, legal conclusions, or strategic assessments.
    - End with a clear statement of what the client should do next, if anything.
    - Do not use legal jargon without a plain-English explanation.

    Tweaks: Build a simple text file with your five active matters’ bullet-point status each Friday afternoon and run this prompt five times in a row. Takes about fifteen minutes total once you have the habit. Some attorneys batch this in a single prompt asking for all five emails at once — results are slightly lower quality but still usable.

    Notes on Using These Prompts

    Model Choice: GPT-4o vs. Claude Sonnet 3.5

    I ran all ten prompts on both GPT-4o (via ChatGPT Plus) and Claude Sonnet 3.5 (via Claude.ai Pro). Short verdict: GPT-4o produces more fluent, polished prose — better for the demand letter, the client email, and the plain-language settlement summary. Claude Sonnet 3.5 is more conservative and flags more aggressively — better for the engagement letter review and the interrogatory draft, where over-flagging is a feature, not a bug. For the conflict check and chronology, they perform comparably. Neither is accurate enough on jurisdiction-specific legal cites to skip your own review.

    Customization Variables to Build In

    Every prompt above has bracket variables. The ones worth standardizing across your practice:

    • [JURISDICTION] — Add this to every prompt. It doesn’t guarantee accurate statutory cites, but it steers the model’s general framing correctly.
    • [PRACTICE AREA] — Narrows the model’s issue-spotting. Without it, you get generic output.
    • [TONE] — Matters more than you’d expect on client-facing documents. Define your client communication style once and paste it in.
    • [ATTORNEY REVIEW NEEDED] — Keep this flag language consistent across all prompts so you know at a glance what the model flagged when you’re editing.

    Where These Prompts Break

    The conflict check breaks when your existing client list is inconsistently formatted — the model can’t catch what it can’t parse. The deposition outline breaks on highly technical expert matters where the model lacks domain context. The demand letter breaks when the legal theory is novel or jurisdiction-specific enough that [INSERT AUTHORITY] placeholders dominate the whole legal basis section — at that point, you’re writing from scratch anyway. The interrogatory draft breaks when client answers are vague or contradictory, because the model fills gaps with plausible-sounding content it doesn’t actually know. Every prompt breaks on long documents that exceed the context window — split them.

    One Hard Rule

    These prompts produce first drafts. You edit, verify, and sign. If a line in the output doesn’t match your actual knowledge of the matter, cut it. The model doesn’t know your client. You do.

    Save these to a note, a doc, or a snippet manager like TextExpander or Raycast Snippets. The ten minutes you spend organizing them now will pay back within the first week you use them.

    Related reading

  • 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