Claude Code for Law Firms: Speed Up Intake Notes and Draft Prep Without Losing Control

Late on a Friday, after the client had left, three sheets of scribbled notes were still sitting on my desk. “Loan, $20k, claim arose April 2024, demand letter sent, other side wants installments.” I didn’t sit down to turn those notes into a draft complaint until the following Tuesday, and by then I could no longer remember exactly when the demand letter had actually been delivered.

I think a law office is exactly the kind of place where this pile up: you took the notes, but you never had time to clean them. New consultations keep coming in. Deadlines keep closing. You know the shape of the document by heart, yet every single time you start from zero and re-arrange the same facts. That re-arranging step is the part I could finally hand off to an AI.

Today I’ll walk through what I actually tested on my own desk: organizing intake notes and prepping the first scaffold of a legal document, delegated to Claude Code. I do not hand legal judgment to the AI. I only hand it the plain, repetitive work that comes before judgment.

Key takeaways

• In a law firm, what you hand to AI is “organizing the facts,” “building the timeline,” and “a rough draft scaffold.” Legal evaluation and the final call stay with a human.
• Just converting intake notes into a fixed structure (parties, claim, timeline, issues, evidence) cut my time-to-start on a document by more than half, by feel.
• I’ve included a copy-paste prompt template and a verification script that mechanically catches names and personal data left in a draft.
• Personal data needs a two-layer rule: “anonymize before you send it” and “use a setting that does not transmit it externally.” Skip this and you risk breaching your duty of confidentiality.
• In rough numbers, prep per consultation dropped from 30 to 40 minutes down to around 10.

Where the law-firm workflow gets stuck

First, let me make the reader clear. This article is written for solo and small-firm attorneys, plus the paralegals and assistants who handle first-pass drafting and record-keeping. I’m not picturing a big firm with a dedicated case-management system; I’m picturing the office that runs on Word and a folder of past documents.

If you lay out a civil matter from intake to filing, it looks roughly like this:

1. Consultation and engagement (notes, recordings, documents the client brings)
2. Hearing out and organizing the facts
3. Building the timeline and the issues
4. Mapping evidence to each assertion
5. Drafting the document
6. Attorney review and legal evaluation
7. Finalize and file

Of these, steps 2 through 5 are heavy on “take scattered information and arrange it into a fixed shape” rather than on judgment. They’re also where rework loves to happen. The classic pattern: you start writing the draft, then realize mid-sentence that you missed a fact and have to call the client back. I’ve done this to myself plenty of times: trying to write the document before I’d built the timeline, then discovering the dates didn’t line up and doing the whole thing twice.

The place AI helps is precisely this prep work in steps 2 through 5. Pour the facts you gathered into a structure, and have it flag what’s missing. Not a finished product, just the fastest possible rough draft. That alone lets you concentrate on step 6 and beyond.

Use case 1: Turn intake notes into a “fact sheet”

Take the scribbles, or the transcript of a recording, and have the AI sort them into fixed fields. The key is to tell the AI not to fill in gaps. If it guesses at facts that aren’t written down, that’s dangerous, so make it write “unconfirmed” wherever it doesn’t know.

Here’s the structure I convert into:

Field	What goes in	When it’s unknown
Parties	Client and opposing party, their roles	Mark “unconfirmed”
Relief sought	What is being demanded (money, eviction, etc.)	List candidates, defer the final call
Timeline	Dates and events, oldest first	Unknown date = “time unclear”
Issues	Points likely to be disputed	Tag guesses with “needs confirmation”
Evidence	Documents brought in, documents not yet obtained	Not obtained = “needs collection”

Just pouring into this structure makes the “fields I forgot to ask about” surface as blanks. The quiet bonus is that those blanks become your next intake checklist.

Use case 2: Check the timeline for contradictions

Once the fact sheet exists, have the AI check only the consistency of the timeline. Not legal correctness, but mechanical things: “are any dates out of order?” and “is the same event written twice?”

When I tested it, the AI caught an input error of mine: “the termination notice arrived before the contract date.” That’s not a legal judgment; it’s plain date-contradiction detection. This kind of simple oversight is exactly what a human misses most.

Use case 3: Build a rough draft scaffold

Hand over the fact sheet and the timeline, and have the AI fill in only the shape of the document. It’s a rough draft, full stop. You’ll rewrite the structure of the argument and the legal evaluation by hand. Only drafts that pass the following checklist move to the next step.

• Party names match the fact sheet exactly
• No fact in the body that doesn’t appear in the timeline
• The conclusion section is blank, or explicitly marked “attorney to confirm”
• No statute numbers asserted on its own (citations stay “needs confirmation”)
• The client’s real name and address are placeholders

The fifth one matters most. By never letting the AI insert real names at the draft stage, you head off a large share of the privacy incidents I describe below.

What to delegate to AI vs. what you decide yourself

This is the line the firm needs to draw for itself. Leave it fuzzy, and one day you’ll file an AI output verbatim by accident.

Step	Delegate to AI	A human always decides
Fact organization	Pouring into the structure, flagging gaps	Whether the facts are true
Timeline	Detecting order and duplicates	Which facts to adopt
Issue spotting	Listing candidates	Whether it holds up legally
Drafting	A scaffold that follows the template	Argument structure, statutes, final responsibility
Filing decision	Nothing	Always the attorney

There’s one principle to the line: “work you can undo goes to AI; judgment that creates liability stays with the human.” Responsibility for the document is the attorney’s, obviously. If you firmly treat the AI as the prep cook, the workflow stops wobbling. If you’re an assistant touching Claude Code for the first time, read Claude Code for non-engineers and getting started with Claude Code first to get the tool’s foundation under you.

A copy-paste prompt template

First, the prompt that converts intake notes into a fact sheet. It assumes you’re pasting anonymized information.

You are a clerical assistant in a law office. Do not make legal evaluations; only organize the facts.

# Input (intake notes, already anonymized)
{paste the anonymized notes here}

# Output rules
- Summarize in a table with these fields: Parties / Relief sought / Timeline / Issues / Evidence
- Do not add facts not written in the input. Where something is unknown, write "unconfirmed"
- Timeline is oldest first. For events with an unknown date, write "time unclear"
- Do not touch the applicability of any statute or the likely outcome
- At the end, list as bullet points the "blanks to fill on the next intake"

When you want the draft scaffold, hand over the output above and add: “leave the conclusion and legal evaluation blank, marked [attorney to confirm]” and “use placeholders like [client] for real names.” Put this operating rule in your CLAUDE.md so you don’t have to repeat the instruction every time. CLAUDE.md best practices is a good reference for how to write it.

Verification script: mechanically catch leftover personal data

Even if your prompt says “don’t insert real names,” a human can still paste the original by mistake. So I keep a script that mechanically checks whether any personal-data-looking strings remain in the text before or after it goes to the AI. It runs with Node.js.

import { readFile } from "node:fs/promises";

// Simple check for patterns that must not be sent / must not remain
const patterns = [
  { name: "Phone number", re: /\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}/g },
  { name: "Email address", re: /[\w.+-]+@[\w-]+\.[\w.-]+/g },
  { name: "ZIP code", re: /\b\d{5}(?:-\d{4})?\b/g },
  { name: "SSN candidate", re: /\b\d{3}-\d{2}-\d{4}\b/g },
  { name: "Account number candidate", re: /\b\d{8,12}\b/g },
];

const file = process.argv[2] || "draft.txt";
const text = await readFile(file, "utf8");

let hit = 0;
for (const p of patterns) {
  const found = text.match(p.re);
  if (found) {
    hit += found.length;
    console.log(`Needs review [${p.name}] ${[...new Set(found)].join(", ")}`);
  }
}

if (hit === 0) {
  console.log("No personal-data-looking strings were found.");
} else {
  console.log(`\n${hit} item(s) need review. Anonymize before sending.`);
  process.exitCode = 1;
}

Running it is just this:

node check-pii.mjs draft.txt

It’s not a perfect detector, but it’s a last gatekeeper against the “oops, I sent the original” accident. I run it twice: once before sending to the AI, and once after I save the draft.

What changed before and after

The numbers shift with firm size, so treat these as rough estimates from my own desk.

Item	Before	After
Prep per consultation	30 to 40 min	~10 min
Callbacks for missed facts	A few a month	Down, thanks to surfaced blanks
Mental load of starting a draft	High (blank page)	Low (scaffold exists)

Say prep shrinks by 25 minutes per matter and you handle 20 a month: that’s about 8 hours. Converted to billable time, that’s a real number you can redirect into review and client meetings, the work that’s actually the attorney’s. Re-run this with your firm’s real figures. If you want to sharpen the instructions you give the AI itself, pair this with advanced prompt engineering.

Security and personal-data notes

Attorneys carry a duty of confidentiality, and handling client information ties directly to professional conduct rules. Here’s the minimum line for using a generative AI.

• Real names, addresses, contact details, and case-identifying information get anonymized before you send anything. Replace them with tokens like [client].
• Use it within a setting and contract that does not train on your input. Don’t paste client information into a personal free tier.
• Don’t file the output verbatim. Responsibility stays with the attorney; the AI is limited to drafting.
• Check where logs and temporary files are saved. Notes left on the device are still under management.
• As a firm, document the rule for “what may be handed to AI” and share it with staff.

If you’re thorough about anonymizing, only generalized facts that can’t identify a client reach the AI. Keep the anonymization key (the mapping table) on paper or offline inside the firm, and never hand it to the AI. For how data is handled, always confirm against the official documentation of the service you use, for example Anthropic’s privacy policy.

FAQ

Q. Can I let the AI make legal judgments? No. What you delegate stops at organizing facts and building draft scaffolds. Applying statutes, predicting outcomes, and final responsibility for the document stay with the attorney. The moment you hand off judgment, the chain of responsibility breaks.

Q. I’m scared to paste client information. That’s the right instinct. Anonymize real names and contact details before sending, and keep the original on your own device. Run the verification script from this article to check for leftovers, and if something still worries you, it’s perfectly fine to decide not to send it to the AI at all.

Q. How accurate is the draft? Not at “file it as is” quality. The bar is “you get a scaffold that follows the template.” You’re meant to fix the selection of facts and the legal structure by hand, so it’s realistic to see it as “a tool that reduces the load of starting from a blank page.”

Q. Can paralegals start this on their own? Yes. Building the fact sheet and surfacing missed facts fit assistant work well. The attorney can step in from reviewing the scaffold that comes out. For running it in the early days, Claude Code productivity tips is a useful reference.

Q. Can I train it on past documents and reuse them? Past documents contain client information, so feeding them in carelessly is dangerous. If you want to reuse them, extract only the “template” with the proper nouns stripped out, and hand over that.

Putting it to the test

I anonymized the loan note from the opening and ran it through the fact-sheet conversion prompt. Parties, timeline, and issues lined up in a table, and at the end it flagged a blank: “delivery date of the demand letter is unconfirmed.” Honestly, that was the single most helpful part. The one thing I couldn’t remember on Tuesday, the AI told me first: “this is missing.”

For the timeline check, I deliberately entered the termination-notice date as earlier than the contract date, and it caught the contradiction. Not legal knowledge, just a date comparison. But in practice, that’s exactly the kind of thing you overlook.

The verification script returned Needs review on a draft where I’d deliberately left a phone number, and the exit code came back 1. It stops that last step where you’d otherwise send something before remembering to anonymize. On the whole, rather than asking the AI to make smart judgments, the shape that fits a law firm is to let it take on the plain work so the human can concentrate on judgment. If you want to design the workflow at the firm level, you can hammer out the concrete flow in training and consulting.