I spend a lot of time in client calls. Discovery sessions, strategy check-ins, implementation walkthroughs. Every one of them generates action items, decisions, and follow-ups that need to be documented. For years I did this manually — typing notes during the call, cleaning them up afterward, sending a summary email. It took 20–30 minutes per meeting, which adds up fast when you're doing 8–12 calls a week.
I've automated the entire process with Claude Code. Now I record the call, drop the audio file into a folder, and three minutes later I have formatted meeting notes, a list of action items with owners, and a draft follow-up email ready to send. The system handles transcription, summarization, and extraction — all the things that used to be manual.
Here's exactly how I built it and how you can do the same.
Why Automate Meeting Notes with Claude Code
Before I get into the how, it's worth explaining why this particular workflow makes sense to automate. Meeting notes are high-volume, low-judgment work. The pattern is the same every time: capture what was said, pull out the decisions and action items, format it cleanly, send a recap. That's a perfect candidate for automation.
The manual approach has three main pain points:
- Time cost — Writing notes during the call splits your attention. Cleaning them up afterward takes another 15–20 minutes.
- Inconsistency — When you're manually typing, some things get missed. Action items slip through if the conversation moves fast.
- Follow-up delay — It's easy to let a day or two pass before sending the recap, which slows down project momentum.
Claude Code solves all three. The transcription is consistent, the action items get extracted automatically, and the follow-up email is ready to send within minutes of the call ending. For my workflow, this has saved about 4–6 hours a week.
The System I Built (High-Level Overview)
The workflow I'm using has four main steps, and each one is handled by a different part of the system:
- Record the meeting — I use Zoom's local recording feature, which gives me an MP4 video file and a separate M4A audio file.
- Transcribe the audio — Claude Code calls the Whisper API (OpenAI's transcription model) and outputs a plain-text transcript.
- Extract and format notes — A second Claude Code script reads the transcript and generates a structured summary: key points, decisions, action items with owners, and next steps.
- Generate follow-up email — The final script takes the formatted notes and writes a short, professional recap email in my voice.
The entire process runs in about 2–3 minutes for a 30-minute call, depending on file size. I review the output for accuracy, make any tweaks, and send it.
Step 1: Recording and File Setup
The starting point is a clean audio recording. I use Zoom's local recording option because it gives me the M4A audio file, which is smaller and faster to process than video. If you're using Google Meet or Teams, you can export the recording and convert it to M4A using a free tool like Handbrake or FFmpeg.
I save all recordings to a dedicated folder on my desktop: ~/Meetings/Recordings/. The file naming convention I use is YYYY-MM-DD_ClientName.m4a, which keeps everything organized and makes it easy to batch-process later if needed.
Step 2: Transcription with Whisper API
The first automation step is transcription. I use OpenAI's Whisper API because it's fast, accurate, and handles multiple speakers well. Claude Code sends the audio file to Whisper and saves the transcript as a plain-text file in the same folder.
The script looks something like this:
import os
import openai
from pathlib import Path
openai.api_key = os.getenv("OPENAI_API_KEY")
audio_file = Path("~/Meetings/Recordings/2026-08-12_ClientA.m4a")
with open(audio_file, "rb") as f:
transcript = openai.Audio.transcribe("whisper-1", f)
output_file = audio_file.with_suffix(".txt")
output_file.write_text(transcript["text"])
print(f"Transcript saved: {output_file}")
This takes about 60–90 seconds for a 30-minute call. The output is a plain-text file with the full conversation, no speaker labels or timestamps. That's fine for my use case — I don't need forensic-level detail, just the content.
Step 3: Extracting Structured Notes
Once I have the transcript, the next step is turning it into useful meeting notes. This is where Claude Code does the real work. I feed the transcript into a prompt that extracts the key information and formats it into sections.
The prompt I use looks like this:
You are a meeting notes assistant. Read the following transcript and produce structured notes. Format: ## Summary A 2–3 sentence overview of what was discussed. ## Key Points - Bullet list of main topics covered ## Decisions Made - List any explicit decisions or agreements ## Action Items - [Owner] Action item description (due date if mentioned) ## Next Steps - What happens next, follow-up meetings, etc. Keep it concise and professional. Use client-friendly language. Transcript: [FULL TRANSCRIPT TEXT]
Claude Code reads the transcript, identifies the relevant parts, and outputs clean, structured notes. The quality is consistently good — better than what I used to write manually, because it doesn't miss anything and it organizes the information logically.
Step 4: Generating the Follow-Up Email
The final step is turning those notes into a follow-up email. I use a second prompt that takes the formatted notes and writes a short recap in my voice. The structure is: quick thank-you, summary of what we covered, action items, and a soft CTA for the next step.
Here's the prompt:
You are drafting a follow-up email after a client meeting. Use the meeting notes below to write a professional, concise email. Tone: friendly, direct, client-focused. Length: 150–200 words. Structure: - Thank them for their time - Recap key decisions - List action items clearly - Suggest next steps or confirm timeline Meeting Notes: [FORMATTED NOTES]
The output is a draft email I can copy into Gmail and send. I usually tweak a sentence or two for tone, but 90% of the time I send it as-is.
What This Looks Like in Practice
Let me walk through a real example. Last week I had a discovery call with a Vancouver-based e-commerce client who wanted to automate their product listing workflow. The call was 32 minutes. Here's what happened:
- Call ended at 2:47 PM. I saved the Zoom recording to the folder.
- Ran the transcription script. Output ready at 2:49 PM.
- Ran the notes extraction script. Formatted notes ready at 2:50 PM.
- Ran the email generation script. Draft email ready at 2:51 PM.
- Reviewed, made one small edit, sent the email at 2:53 PM.
Total time from call end to email sent: 6 minutes. The client replied 20 minutes later saying it was the most thorough follow-up they'd ever received from a consultant.
Common Issues and How to Fix Them
This system works well, but it's not perfect. Here are the three most common issues I ran into during the first month, and how I solved them:
Issue 1: Transcription Errors with Background Noise
If the call has a lot of background noise or if the client's mic quality is poor, Whisper will make more transcription errors. The fix: use Zoom's built-in noise suppression during the call, and if the transcript still has issues, run a quick cleanup pass with Claude Code to fix obvious mistakes before extraction.
Issue 2: Action Items Without Owners
Sometimes the conversation doesn't make it clear who owns an action item. The extraction script will list the item but leave the owner blank. The fix: I added a manual review step where I assign owners before generating the email. Takes 30 seconds.
Issue 3: Overly Verbose Summaries
Early on, Claude Code was writing summaries that were too detailed. I fixed this by adding a word count constraint to the prompt: "Summary must be 2–3 sentences, maximum 60 words." That tightened it up immediately.
Time and Cost to Build This
If you want to replicate this system, here's what it takes:
- Time to build — About 2–3 days if you're comfortable with Python and API integration. If you're new to this, expect closer to a week.
- Cost to run — Whisper API charges $0.006 per minute of audio. For a 30-minute call, that's $0.18. Claude API calls for extraction and email generation add another $0.05–0.10 per call. Total cost per meeting: about $0.25.
- Ongoing maintenance — Minimal. I've made two tweaks to the prompts in six months of use.
For someone doing 8–10 calls a week, the time savings alone justify the build cost within the first month.
Who This Works For
This workflow makes sense if you're doing a high volume of client calls, internal meetings, or strategy sessions where documentation matters. It's especially useful for:
- Consultants and agencies who need to send detailed recaps after every client call
- Project managers who run regular team syncs and want consistent documentation
- Sales teams who need to capture action items and follow-up tasks from discovery calls
- Anyone who finds themselves manually typing the same kinds of notes over and over
If you're only doing one or two meetings a week, the manual approach is probably fine. But if you're doing five or more, this will give you hours back every week.
Next Steps If You Want to Try This
If you want to build your own version, here's where I'd start:
- Set up a Whisper API account and test transcription on a single recorded call
- Write a basic extraction prompt and run it on the transcript manually in Claude's web interface
- Once the output quality is good, automate it with a Python script
- Add the email generation step last, after the notes workflow is solid
If you'd rather have me build this for you, I do this kind of work for clients regularly. The typical timeline is one week from kickoff to working system. You can book a call here if you want to talk through your specific use case.
And if you're curious about other ways to use Claude Code for client workflow automation, check out my posts on automating client onboarding and CRM workflow automation. A lot of the same principles apply.
The tools are here. The question is just whether you want to keep doing this manually or give yourself the time back.