The Python Scripts Accountants Are Quietly Writing (and How AI Writes Them for You)

In a practitioner community thread we read this week, accountants compared notes on something the profession rarely discusses in public: the little programs they've written for themselves. One solo practitioner runs a pipeline that takes tax-office correspondence, redacts the identifiers, renames each document, and attaches it to a draft email for the right client. Another feeds prefill data straight into tax return workpapers. A third runs old-school VBA that compiles activity statement reports and completes the recs. One built his own booking system, wired to Google Calendar and a digital-signature site, specifically to avoid two more subscriptions.

None of them would call themselves developers. What they've found is a middle layer that the "learn Python" courses and the no-code app platforms both skip over: the tiny, single-purpose script. Not an app. Not a system. A short program that does one boring thing you currently do by hand every week, in four seconds instead of twenty minutes.

Here's what changed: you no longer need to write these yourself. Describe the chore to Claude or ChatGPT in plain English and it produces working Python. Tools like Claude Cowork go further and just do file tasks without showing you code at all (our Cowork setup guide for accounting firms covers that route). The skill that matters is no longer syntax. It's describing your own process precisely, which accountants are already good at.

Five scripts worth stealing

Each comes from a real workflow practitioners described, generalised so you can adapt it: what it does, and the plain-English prompt you'd hand to an AI. You don't need to understand the code that comes back. You need to test it on copies, which we'll get to.

1. The tax-office mail handler: redact, rename, file

Tax agents receive a steady drip of official correspondence: assessments, statements of account, debt letters. Each needs identifiers redacted before it goes anywhere near email, then a sensible filename, then filing against the right client. By hand, that's a few minutes per document, many times a week.

"Write a Python script that watches a folder for new PDFs. For each one, black out any 9-digit number formatted like a tax file number, extract the client name from the first page, rename the file to ClientName_DocumentType_Date.pdf, and move it into a subfolder named after the client. Log everything to a text file. If it can't confidently identify the client, move the file to a 'needs review' folder instead."

That last sentence matters most. A good chore script always has a "not sure, human please" pile.

2. The prefill-to-workpaper transfer

Prefill reports arrive as PDFs or downloads; your workpapers live in Excel. The gap between them is retyping, and retyping is where transposition errors live.

"Write a Python script that reads a tax office prefill report PDF, extracts the interest, dividend, and salary figures with their payer names, and writes them into the matching labelled cells of my Excel workpaper template (attached). Don't overwrite any cell that already has a value; flag those in a summary instead."

Attach a dummy-client prefill and your actual template, and the AI writes against your real layout rather than a guess.

3. The activity statement rec compiler

One practitioner in the thread runs this in VBA rather than Python, a useful reminder that the language is beside the point. If your firm lives in Excel, VBA is fine. The chore is the same: pulling figures from several sources into one rec and highlighting what doesn't tie.

"Write a script that opens the GST report exported from my ledger and the lodged activity statement figures (both spreadsheets, samples attached), lines them up by period, calculates the variance per label, and produces a one-page reconciliation highlighting any variance over $1, saved as a new file named for the client and quarter."

4. The bulk file tidier

Every firm has a drive with fifteen years of inconsistent naming: "Final v2 FINAL", scans named by the photocopier. Nobody will ever fix this by hand. A script will fix it in an afternoon.

"Write a Python script that scans a folder tree of client documents and renames every file to the convention ClientCode_Year_DocumentType, inferring the year and type from the file's contents or metadata. Produce a preview spreadsheet of every proposed rename first, and only apply the changes after I've reviewed it and re-run the script with a confirm flag."

Preview-then-confirm is the pattern to insist on for anything touching files in bulk. Never let a first-run script rename thousands of documents unsupervised.

5. The booking system that isn't a subscription

The most ambitious build in the thread: a booking flow linked to Google Calendar, plus a digital-signature service for lodgement declarations, built to avoid two recurring software bills. For a solo practice, that's real money back every year.

"Write a Python script that reads my Google Calendar availability, generates a simple web page listing open 45-minute slots, and when a client picks one, creates the event, emails a confirmation, and sends a link to sign the engagement declaration through my e-signature provider's API."

Worth being honest: this one is closer to an app than a script, and the practitioner who built it said as much, calling hand-rolled systems fun but "probably a dead end eventually". He's right, and we'll come back to why. If you're drawn to this end of the spectrum, our pieces on building apps without writing code and what happens to a firm that builds its own tools map the territory past the script layer.

How to get AI to write yours

The pattern that works, watching non-coders do this successfully:

1. Describe the input. What files, what format, where they live. Attach a dummy-data sample if you can.
2. Describe the output. What should exist afterwards, named what, saved where.
3. Describe the edge cases. What does a malformed one look like? What should happen when the script isn't sure? "Move it to a review folder and tell me" is almost always the right answer.
4. Test on copies. Duplicate a folder of real files, point the script at the copy, and check the results the way you'd check a junior's work. Because that's exactly what this is.
5. Keep versions. Save working scripts with a date in the filename, or better, in a private GitHub repository, so you can always roll back after a change.

You review, it types. You never need to read the code line by line, but you do need to verify the output, exactly as with any delegated work. If even that feels like too much ceremony, the Cowork route (describe the file task, let the agent do it, review the result) gets you most of the benefit with none of the maintenance.

And the objection every practitioner raises first, answered plainly: a script that runs on your own machine is a strong privacy position. Client files never leave your computer. No third-party processor, no data residency question, no new entry in your privacy policy. The AI sees your description and dummy samples; real client data only ever meets the script, locally.

The honest limits

Three, and they're real.

The dead-end risk. The practitioner who called his own system a probable dead end was describing what every home-built tool eventually faces: commercial software catches up, integrations become table stakes, and maintenance quietly becomes a second job. Scripts age better than apps precisely because they're small. A 40-line file renamer is trivially rewritten; a bespoke practice management system is a trap.

The key-person risk. If one partner wrote the scripts and one partner understands them, your firm has an undocumented dependency. Mitigation is cheap: one shared folder, and a plain-English README per script saying what it does, what it expects, and what to do when it breaks. AI will happily write the READMEs from the code.

The buy-instead line. Scripts stop being the right answer the moment you need multiple simultaneous users, access from outside your machine, or someone to call when it breaks during lodgement season. Multi-user, web access, support. Need one of those? Buy the software and don't look back.

Where this is heading

Today you describe a chore and AI writes a script you run yourself. The next step, already shipping, is describing the chore and having an agent just do it: Cowork sessions that read, rename, and file documents on instruction, and the wider wave of agentic AI in accounting where tools plan the steps as well as execute them. The script layer is still worth learning, because the skill transfers: people who can precisely describe an input, an output, and the edge cases will get good results out of agents. Everyone else gets plausible-looking wrong answers. For the wider picture, start with our AI for accounting firms hub.

Pick the chore that annoyed you most last week. Write down its input, its output, and its edge cases before you open any AI tool. That description is the asset; the code is just its shadow.

Frequently asked questions

Do accountants need to learn Python?

No. You need to describe a process precisely, which your training already gave you; AI handles the syntax. Practitioners running these scripts mostly can't read the code they use, but they can, and do, verify its output.

Is it safe to run scripts on client data?

Safer than most alternatives, with two conditions. Run everything on copies until a script has proven itself, with preview-then-confirm for bulk changes. And keep real client data out of the AI conversation: describe the task with dummy samples, then run the script locally, where real files never leave your machine.

What happens when the script breaks?

Usually it breaks loudly (an error message) rather than silently, especially if you asked for logging and a review folder up front. Paste the error back into the AI that wrote it and you'll typically have a fix in minutes. The real protection is upstream: dated versions you can roll back to, and a README so anyone in the firm knows what it was supposed to do.

Script, app, or just buy software?

A script suits a single recurring chore, run by one person, on one machine: renaming, extracting, reconciling, compiling. An app suits workflows with a screen, multiple users, or client-facing touchpoints; our guide to building apps without code covers when that leap makes sense. Buy commercial software the moment you need multi-user access, web access, or a support line.

Where should I start this week?

Choose one chore that takes 15 to 30 minutes and happens weekly. Write three short paragraphs: what goes in, what comes out, and what the weird cases look like. Hand that to Claude or ChatGPT and ask for a Python script with logging and a review folder for anything it's unsure about. Run it on a copied folder, check the results like a reviewer, and promote it after two clean weeks.