I do a lot of contract drafting, NDA review, and client communication work. Started using AI for it about a year ago. The dirty secret: the quality gap between a bad prompt and a good one in legal work is enormous.
A bad prompt produces generic legalese that needs total rewriting. A good prompt produces a usable first draft. The difference is almost never the model — it is the structure of the ask.
Here is what I figured out.
The core pattern: role + constraints + output format
Every legal prompt that works for me has three parts:
[ROLE]: You are a [practice area] attorney reviewing [document type].
[CONSTRAINTS]: Jurisdiction: [STATE/COUNTRY]. Client type: [INDIVIDUAL/BUSINESS].
Assume: [KEY ASSUMPTION]. Do not: [THING TO AVOID].
[FORMAT]: Output a [FORMAT] covering [SPECIFIC SCOPE].
Flag any [RISK TYPE] with a one-sentence plain-English explanation.
The "do not" line does most of the work. Without it, models default to maximally hedged, disclaimer-heavy output. Telling the model what to skip sharpens the response significantly.
The 50 prompts by category
Client intake (8 prompts)
- Conflict check memo (takes client name + matter description, flags potential conflicts)
- Non-engagement letter (3 variants: conflict, scope mismatch, capacity)
- Retainer clause explainer (translates fee language into plain English for the client)
- Initial consultation summary
Legal research (9 prompts)
- Case summary (input: raw case text, output: issue/holding/reasoning in 200 words)
- Jurisdiction comparison (same legal question across two states)
- Deposition outline generator
- Statute plain-English summary
- Counter-argument spotter (reads your draft argument, surfaces the opposing view)
Drafting (10 prompts)
- NDA redline reviewer (flags one-sided clauses with explanations)
- Contract summary (for clients who will not read the full agreement)
- Settlement agreement first draft
- Interrogatory response set
- Cease and desist (3 tones: firm, aggressive, de-escalating)
Client communication (8 prompts)
- Case status update email
- Bad news delivery (structure: fact → context → options → next step)
- Fee dispute response
- Client boundary-setting email
Practice management (15 prompts)
- Google Business Profile bio
- LinkedIn post series (5 prompts, one per week of content)
- SOP draft (input: process description, output: numbered SOP with decision points)
- CLE tracker summary
- Year-end business review
The most useful single prompt
The contract summary for clients:
You are a [PRACTICE AREA] attorney. A client has asked you to explain this contract
in plain English. They are [SOPHISTICATED/NON-SOPHISTICATED].
Do not use legal jargon. Do not add hedges or disclaimers —
I will add those separately.
Summarise the following sections in 2-3 sentences each:
- Parties and purpose
- Key obligations (each party)
- Payment terms
- Termination triggers
- Anything unusual or one-sided
Flag any clause that a [CLIENT TYPE] should negotiate before signing,
with a one-sentence plain-English reason.
[PASTE CONTRACT HERE]
Clients read this. They do not read a 40-page agreement.
One important note
None of this replaces legal judgment. Every output needs attorney review before it goes anywhere. The prompts are for generating usable first drafts, not final work product.
Full pack of 50 prompts (PDF + Markdown, copy-paste ready with bracket placeholders): https://pirateprentice.gumroad.com/l/sklcrpo ($29 one-time).
If you build legal tech or use AI for your own legal paperwork — what prompts have you found that actually work? Always looking for patterns I have not tried.
Related Articles
- n8n OpenAI Node: Generate Text, Images, and Chat Completions in Your Workflows
- n8n AI Agent Node: Build Autonomous AI Workflows with Tools, Memory, and Multi-Step Reasoning
- n8n Anthropic Chat Model Node: Connect Claude to Your AI Agent Workflows
Free: n8n Integration Checklist
25 production checks before you ship any n8n workflow — credentials, error handling, dedup, and integration-specific gotchas. Takes 2 minutes to run.
Want this built for you? I build production-ready n8n workflows for small businesses — fixed price, 48-hour turnaround, honest refund policy. See the service and get a quote → occelatus.io/automate
Top comments (8)
The useful part here is treating the prompt as a reusable work product, not a one-off chat: role, jurisdiction/client constraints, and a fixed output format make review faster because the variance is smaller. The "do not" line is underrated too, especially in legal work where a model will otherwise drown a plain-English contract summary in hedges. From a founder/engineer angle, I'd treat these like internal tools: version them, test them against real NDAs or status emails, and keep examples of bad outputs so the prompt improves based on failure modes instead of vibes.
The versioning angle is exactly right — I keep a short changelog per prompt noting what each tweak fixed and what failure mode triggered it. The most common failure I've hit: telling the model the client is "sophisticated" when they actually aren't, and getting output that's technically correct but still incomprehensible to them. The model defers to the stated sophistication level rather than the actual clarity bar you need. Fixing it required adding a second constraint: "explain each clause as if the client has not read a contract before, regardless of their stated background." That kind of failure-mode example is what makes the prompts actually improve over time rather than just accumulate.
A changelog artifact per prompt is a challenging task to manage over 50 prompts, but it sounds like that work is paying off for you. Curious what generalized repo-wide parameters you set for generating brand new contracts, and if those individual changelogs inform those parameters if you have them.
Yes — the changelogs absolutely feed back into the repo-wide params, and that loop is where the real leverage is.
For contract generation specifically, the global parameters I've settled on are: (1) jurisdiction default (e.g. "California, US" — set once, stops the model from guessing Delaware every time), (2) formality register ("plain English, 8th grade reading level" vs "legal standard prose" — pick one per client tier and lock it), (3) party naming convention (define COMPANY and CLIENT upfront in the system prompt so the model doesn't drift between 'the Client', 'Customer', and 'you' mid-document), and (4) output format (markdown headings + numbered clauses vs continuous prose — different reviewers want different things).
The changelog earns its keep when you see the same failure mode surface in 2–3 individual prompt logs — like jurisdiction drift, or the model adding hedge language even after you told it not to. When it's isolated to one prompt, you fix that prompt. When it shows up across three prompts, you know it's a global param issue and you fix it at the repo level instead of patching each prompt separately. That's the actual feedback loop: individual changelogs as signal aggregators, not just per-prompt notes.
That makes sense, and it’s very interesting. The whole mindset of managing a portfolio of prompts as an asset is novel, and I think you’re signaling a new trend in AI that we haven’t anticipated. You’re on a goldmine in my opinion if you wanted to teach others how to make prompt portfolios like this. Much anticipating future updates about this!
That’s great. Bookmarked your product. It’ll be useful knowledge for developing engineering prompts for my customers. Thanks and looking forward to more!
Thanks Marcus — the engineering prompts for your customers framing is exactly where this goes next: from personal tooling to structured assets you hand off as part of a service. That shift from 'I use this' to 'I give this to clients' is where prompt portfolios get genuinely interesting. Happy to swap notes if you hit edge cases on the engineering side. Looking forward to more from you too.
Some comments may only be visible to logged-in visitors. Sign in to view all comments.