How a Tax & Accounting Firm Drafts Client Emails and Review Checklists with Claude Code

On the first morning of every month, a tax accountant I know lets out the same sigh.

“I have to write this email from scratch. Again.”

Thirty clients, each one waiting for the same message: this month’s trial balance is ready, here are the items I need you to check, here are the documents you still owe me. Eighty percent of every email is identical across all thirty companies. But to swap in the company name, the numbers, and the one or two “this client is a special case” notes, he opens a blank window and retypes the whole thing every single time. And then, rushing one out the door, he writes “your company’s sales tax” but pastes in a different client’s company name, and has to make an apologetic phone call to clean it up.

This is the work that is “eighty percent the same, but the twenty percent absolutely cannot be wrong.” That is the quiet drain on a tax and accounting firm. Today I want to show you how to reshape it so Claude Code writes the first draft and a human makes the final call.

Key takeaways

• Client emails and review checklists at an accounting firm follow a fixed “shape,” so building templates with Claude Code removes the monthly retyping.
• Let the AI handle assembling the wording and flagging gaps. The accuracy of the tax figures, the eligibility rules, and hitting “send” must always stay with a human.
• Keep client financials and personal data safe by stripping the names and numbers before you hand anything to the AI. Write down one firm-wide rule and stick to it.
• This article gives you a copy-paste prompt template, a review checklist, and a small check script that mechanically catches the things you forgot to swap out.
• At twenty clients a month, saving 15 minutes per client adds up to 5 hours a month, enough to cut your support staff’s overtime by a meaningful amount.

First, break this work down

The reader I have in mind is a small-to-midsize accounting firm with 10 to 50 clients. One to three licensed accountants run it, with a handful of support staff handling bookkeeping and routine audits. The accounting software is whatever is common in your market: QuickBooks, Xero, FreshBooks, Wave. Firms like this are by far the most common.

The monthly client cycle usually runs like this:

1. Finalize the monthly trial balance and the period-over-period report in the accounting software.
2. Staff pick out the unusual figures and the line items with big month-over-month swings.
3. Email the client to say “your trial balance is ready” and “please check these items.”
4. The client replies with missing receipts or questions about how something was categorized.
5. For clients whose year-end is approaching, send a separate review checklist for the month.

Of these, steps 3 and 5, “write the explanation” and “build the checklist,” happen by hand almost every month. The skeleton of the content is fixed, but turning it into prose costs effort every single time. That is exactly where Claude Code earns its keep.

The common do-overs, and what changes after you adopt this

Let me name the do-overs specifically. You will recognize them.

Common do-over	Cause	What it costs you
Sent with another client’s name or numbers still in it	Copied last time’s email and missed a swap	An apology and lost trust
The “please check this” explanation reads differently every time	Each staffer writes it their own way	Client confusion, more inbound questions
Items get dropped from the year-end check	The list lives in one person’s memory	Missing documents surface right before filing
The jargon is too stiff for the client to follow	Sent in raw tax-speak	”So what do I actually do?” comes back

Before adopting this, staff would stare at an empty email window starting from “uh, how did I word it last month?” After, you hand over this month’s numbers and special notes as bullet points, and a draft in your firm’s standard tone comes back in tens of seconds. The staff’s job changes from “write from scratch” to “fix the draft through an accountant’s eyes.”

Editing a rough draft is faster and less draining than squeezing prose out of a blank mind. It is the same as bookkeeping or preparing a return: proofreading is lighter than going from zero to one. If you have never touched Claude Code, read the getting started guide for first-time Claude Code users first, and the prompts below will run as-is.

Use case 1: Templatize the monthly trial-balance email

The monthly “your trial balance is ready” email. We make the AI draft it from nothing but the numbers and the special notes.

First, put your firm’s standard tone into words exactly once. Pin it to the top of the prompt and anyone gets the same quality.

You are a support staffer at a tax and accounting firm. Draft the monthly
trial-balance notification email we send to a client.

# Firm tone
- Polite and professional. When a technical term appears, add a plain-English
  restatement the first time it shows up.
- Keep sentences short. Put the "please check" items in a numbered list.
- Use the numbers exactly as given. Do not fill in any figure by guessing.

# This month's information
- Client name: __ (company name here)
- Period: __ / __ (month, year)
- Accounts with large month-over-month moves: __ (e.g., entertainment up $1,800 vs. last month)
- Items to confirm: __ (e.g., the $1,000 cash withdrawal on 5/12, what it was for)
- Missing documents: __ (e.g., April credit card statement)

# Output
A subject line and a body. Close with "Please don't hesitate to reach out with
any questions." If you assumed any number or fact, list it explicitly at the
bottom under [NEEDS REVIEW].

That last line, “make it self-report what it assumed under [NEEDS REVIEW],” is the crux. The AI wants to fill in blanks, so forcing it to declare what it invented makes the human check dramatically easier.

If you want to raise the floor on how you write prompts in general, the deeper dive on Claude Code prompt design and its “role, constraints, output format” framing is worth your time.

Use case 2: Generate a pre-close review checklist

As the year-end month approaches, you confirm “do you have all of this?” for each client. If staff rebuild those items from memory every time, something always gets dropped.

So keep your firm’s standard check items in a single text file, and let the AI keep or drop them to match the client’s industry.

From the master list below, select only the items that apply to this client and
build a pre-close review checklist.

# Client context
- Industry: __ (e.g., restaurant, single location)
- Entity type: __ (corporation / sole proprietor)
- Sales tax treatment: __ (e.g., standard / simplified / exempt)

# Master items
- Unrecorded sales (post-cutoff sales, unbilled amounts)
- Inventory quantity and valuation
- Fixed-asset additions, disposals, and depreciation
- Loan repayment schedule and interest
- Owner compensation and bonuses actually paid
- Spoilage write-offs for inventory-holding businesses
- Cash-on-hand reconciled to the books for cash businesses
- Sales tax totals by treatment category

# Output
Checkbox format (- [ ]). Add one line to each item explaining why you check it.
Drop items that do not apply. Put anything you are unsure about at the end under
[ACCOUNTANT TO CONFIRM].

Put in “restaurant” and the cash balance and spoilage items stay; put in “IT contract development” and inventory drops out. Only what that client actually needs comes through.

The output looks like this:

## Acme Store — Pre-Close Review Checklist (April year-end)

- [ ] Post-cutoff sales not slipping into the next period (timing differences hit tax directly)
- [ ] Inventory quantity and unit cost as of 4/30 (valuation swings the profit)
- [ ] Register cash reconciled to the book balance (cash businesses drift easily)
- [ ] Spoiled-food write-offs recorded (reflected in cost of goods?)

[ACCOUNTANT TO CONFIRM]
- Is the simplified-method business category still appropriate this year?

Use case 3: Draft replies to client questions

“What does this account mean?” “Can I deduct this expense?” The direction of the answer is already decided, but writing it out politely every time is a chore.

The important thing here is not to let the AI make the tax judgment itself. The accountant states the call in one line, and the AI sticks strictly to being the “translate it into words the client understands” department.

Using the accountant's policy note, write a clear reply to the client's question.
Follow the policy note for any interpretation of tax law or whether something is
allowed. Do not add or change any judgment.

# Client's question
"Is the coffee I bought during a business meeting deductible?"

# Accountant's policy note (follow only this)
- If it was a genuine business meeting, yes, as a meeting expense.
- But record who you met and the purpose. Personal items are not deductible.

# Output
Soft, professional tone. Briefly explain any term (like "meeting expense").
Do not write any exception that isn't in the policy note.

This gives you something like “Yes, you can record it as a meeting expense. Just keep a note of who you met with and the purpose,” in the firm’s tone, without the AI inventing rules.

What to delegate to the AI vs. what a human must decide

This is the single most important part for an accounting firm. Draw the line clearly.

Step	Delegate to Claude Code	A human (accountant) decides
Assembling the wording	Yes, generate the draft	Approve the final phrasing
Surfacing gaps	Yes, list the check items	Final call on whether each item is needed
Calculating tax and rates	No, never	Yes, a human calculates and double-checks
Judging eligibility	No, never	Yes, a human confirms exceptions and rules
Sending to the client	No, never	Yes, a human always hits send

The mnemonic is simple. “Write and arrange” is the AI; “decide if it’s correct and send it” is the human. Asking the AI for tax figures or eligibility and taking them at face value is about as dangerous as distrusting your calculator and punching the keys on a hunch. Always cross-check any number or rule the AI produces against the source documents.

As a foundation for sharing this line with non-engineer staff, circulate the guide to getting non-engineers started safely with Claude Code around the office once, and you’ll see fewer accidents from odd usage.

Security and personal-data notes

Client financials are bona fide personal and confidential information. Do not compromise here.

• Strip names and specific amounts before handing anything over. When you pass data into the prompt, anonymize it as “Client A,” “revenue $XX.” A human puts the correct company name and numbers back into the draft afterward.
• Decide a one-page AI usage policy for the firm. Spell out which tool may receive what, and what it must never receive (tax IDs, bank account numbers, raw financial-statement PDFs).
• Make a human eyeball mandatory before sending. Any text the AI writes must be read by the responsible accountant before it goes out. No auto-send.
• Don’t wire it directly into the accounting software. For now, keep it to manual copy-paste and avoid automatic writes to production data.

For a concrete way to share firm rules across the team, the CLAUDE.md best practices article is a good reference. Writing your project rules into a single file means anyone can run the same way on the same assumptions. Before you start, it’s also worth reviewing official guidance on handling personal data, for example the IRS guidance for tax professionals.

Copy-paste: a missed-swap detector script

Here is a small script that mechanically checks whether your draft email still has any “forgot to swap” leftovers. It catches a previous client’s name still sitting in the text, an unfilled placeholder (__), and the like, before you send. It runs anywhere you have Node.js.

Save it as check-draft.mjs and run node check-draft.mjs draft.txt.

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

const file = process.argv[2];
if (!file) {
  console.error("Usage: node check-draft.mjs draft.txt");
  process.exit(1);
}

const text = await readFile(file, "utf8");

// The correct client name (the actual recipient) goes here.
const correctClient = process.env.CLIENT_NAME || "Acme Store";

// Other client names you tend to leave in from past emails. Add your real ones.
const otherClients = ["Sample Corp", "Test Industries", "Maple Clinic"];

const issues = [];

// 1) Unfilled placeholders
if (text.includes("__")) issues.push("Placeholder __ is still present");

// 2) Flag a leftover [NEEDS REVIEW] tag (in case you forgot to remove it)
if (text.includes("[NEEDS REVIEW]"))
  issues.push("[NEEDS REVIEW] is still present. Check the contents.");

// 3) Another client's name leaking in
for (const name of otherClients) {
  if (text.includes(name)) issues.push(`Another client name "${name}" is present`);
}

// 4) The recipient's name never appears
if (!text.includes(correctClient)) {
  issues.push(`Recipient "${correctClient}" does not appear in the body`);
}

if (issues.length === 0) {
  console.log("Check OK: proceed to the final human review before sending.");
} else {
  console.log("Needs fixing:");
  for (const i of issues) console.log(" - " + i);
  process.exit(1);
}

It is not perfect detection. But the scariest accident, “sent with the previous company’s name still in it,” is almost entirely stopped by this alone. The trick is to list your own client names in otherClients. With Claude Code you can rewrite this script just by asking, “put my ten client names into the array.”

A rough ROI estimate

Let me sketch it out. Say you have 20 clients, and you build a monthly notification email and a review checklist for each one every month, and writing each by hand used to take 20 minutes.

• Before: 20 clients x 20 min = 400 min/month (about 6.7 hours)
• After: draft plus human edit at 5 min each = 20 clients x 5 min = 100 min/month (about 1.7 hours)
• Difference: roughly 5 hours saved per month

At a support-staff rate of $20/hour, that’s about $100 of labor a month, and the effect balloons during year-end season. Bigger than the dollars, though, may be that the “apologize for the wrong company name” phone call disappears.

If you’d rather start small without chasing numbers, the collection of small Claude Code productivity tips is a good place to adopt just one habit and keep it going.

FAQ

Q. Can I let Claude Code do the tax calculation too? No. The AI is good at assembling explanations, but it does not guarantee the accuracy of tax figures or eligibility rules. Calculation and judgment must be done by the accountant; keep the AI to “restating decided content for the client.”

Q. Is it fine to paste in the client’s financial statements as-is? Avoid it. Hide company names, amounts, and tax IDs, and hand over an anonymized version as a rule. The safe pattern is to have a human put the correct names back into the draft afterward.

Q. Can staff who aren’t comfortable with computers use it? Yes. All they do is ask in plain English and check the result. Have the lead accountant prepare one template prompt first, and have staff start by pouring numbers into it. They won’t get stuck.

Q. Can it connect automatically to the accounting software? Technically yes, but I don’t recommend it at first. Automatic writes to production data carry a heavy blast radius, so for now keep it to copy-paste and to “produce a draft.”

Q. How do I guarantee the quality of the text it produces? Pin your firm’s standard tone to the top of the prompt, run the check script above to catch mechanical accidents, and have the accountant eyeball it last. That three-layer setup reduces the quality variance between staff.

What I found when I actually tried it

I went ahead and built monthly notification emails for five fictional clients using the template prompt and check script above.

I wanted to confirm two things. First, “if I pin the firm tone to the top, does the per-client variance in wording really disappear?” The result: all five came out with the same level of formality and the same closing. Even the granularity of the numbered lists was consistent.

Second, “does the script catch another client’s name leaking in?” I deliberately left a previous company’s name in one email and ran the check, and it stopped cleanly with Another client name "Test Industries" is present. It also caught the leftover __ placeholder.

It also showed me a limit. When I asked the AI about the sales-tax treatment category, it returned a confident-sounding explanation, but it had the simplified-method business category wrong by one. So the judgment stays with a human. Drafting and gap-checking are the AI’s job; correctness and sending are the accountant’s. As long as you hold that line, the monthly drain gets a lot lighter. That’s my honest takeaway from trying it.

If you want to build this into your firm’s workflow for real, in training and consulting we can work out a design tailored to your firm’s process together. If you’d rather get your own hands dirty first, start from the learning materials and free PDF.