Summarizing Meetings and Extracting Action Items

Zack’s assistant could listen to a meeting and spit out a transcript. It was a game-changer. He no longer had to scramble to write notes while listening.

But after the excitement wore off, Zack hit a new problem.

The transcript was long. Pages and pages of text. Even a short 30-minute meeting could generate thousands of words.

“This is better than nothing,” Zack thought, “but I still don’t have the highlights. I don’t know the decisions. I don’t know the action items. I can’t send this wall of text to my team.”

That’s when he realized: the real power wasn’t in having all the words. It was in turning those words into clear, concise summaries and task lists.

Step 1: Summarizing transcripts

Zack thought back to his team’s weekly sync. The transcript looked something like this:

1
2
3
4
[00:00] Zack: Thanks for joining. We need to discuss the testing deadline.  
[00:05] Sara: QA team says we need three extra days.  
[00:10] Ali: That means moving launch from March 10 to March 13.  
[00:20] Zack: Okay, let’s confirm. Sara will update the project plan. Ali will notify the client.  

That’s fine to read once. But imagine 30 minutes of back-and-forth, jokes, tangents, and side conversations. Who has time to read it all?

A summary solves this:

• “Team decided to move testing deadline from March 10 to March 13. Sara will update the plan; Ali will inform client.”

And action items make it practical:

• Sara: update project plan
• Ali: notify client about new launch date

Now the transcript becomes something people actually use.

Step 2: Designing prompts for meeting summaries

Zack remembered what he learned from emails: the prompt makes all the difference. He started experimenting with meeting transcripts.

Basic prompt:

“Summarize this meeting transcript.”

• Output: “Team discussed project testing.” (too vague).

Improved prompt:

“Summarize this transcript in 3–5 sentences. Include key decisions and deadlines.”

• Output: “Team decided to move testing deadline from March 10 to March 13. Sara will update project plan. Ali will notify client.” (better).

Best prompt (digest + tasks):

“Read this transcript and return two sections:

1. Summary of key discussion points and decisions (3–5 sentences).
2. List of action items in JSON format with owner, task, and due_date if mentioned.”

Output:

Summary:
“The team agreed to extend QA testing by three days, moving launch to March 13. Sara will revise the project plan, and Ali will inform the client.”

Action Items:

1
[ {"owner": "Sara", "task": "Update project plan", "due_date": null}, {"owner": "Ali", "task": "Notify client about new launch date", "due_date": null} ]

Now Zack had both human-readable notes and structured tasks his assistant could track later.

Step 3: Handling long transcripts

One obstacle remained. Some meetings went on for an hour, generating transcripts too long for a single API call.

That’s where Zack applied the same trick he used for email threads: chunking.

1. Split transcript into chunks (about 1000 words each).
2. Summarize each chunk separately.
3. Combine chunk summaries into one final summary.
4. Extract action items across all chunks.

This way, even a two-hour all-hands meeting could be reduced to a single digest.

Step 4: Coding the meeting summarizer

Zack created a new file summarize_meeting.py.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
from openai import OpenAI
import json

client = OpenAI()

def summarize_transcript(text):
    prompt = f"""
    You are a meeting assistant. Read the transcript below and return:
    1. A summary of key discussion points and decisions (3–5 sentences).
    2. A list of action items in JSON format with keys: owner, task, due_date (null if not mentioned).

    Transcript:
    {text}
    """
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content.strip()

def main():
    # For now, use a sample transcript
    transcript = """
    Zack: Thanks everyone. QA says testing needs 3 extra days.
    Sara: Okay, that moves launch to March 13.
    Ali: I’ll notify the client.
    Zack: Perfect. Sara, please update project plan.
    """
    result = summarize_transcript(transcript)
    print("=== Meeting Summary ===")
    print(result)

if __name__ == "__main__":
    main()

Step 5: Testing the script

When Zack ran:

1
python summarize_meeting.py

He got:

1
2
3
4
5
6
7
8
=== Meeting Summary ===
The team discussed QA testing timelines and agreed to extend by three days, moving the launch to March 13. Sara will update the project plan. Ali will notify the client.

Action Items:
[
  {"owner": "Sara", "task": "Update project plan", "due_date": null},
  {"owner": "Ali", "task": "Notify client about new launch date", "due_date": null}
]

Exactly what he needed: a clean summary and a to-do list.

Step 6: Exercise

Here’s your challenge:

• Take the transcript you created in Lesson 6 (1-minute audio).
• Save it as transcript.txt.
• Modify Zack’s script to:
  • Read the text from the file.
  • Pass it to summarize_transcript().
  • Print the summary and action items.

Expected output:

1
2
3
=== Meeting Summary ===
Summary: Key decisions and main points (3–5 sentences).  
Action Items: JSON list of tasks with owner and due dates.  

Even if your transcript is just you talking, it’s good practice.

Zack’s feedback

After running his first full meeting summary, Zack was amazed.

“This is the part I always dreaded,” he said. “Writing notes after a meeting. But now my assistant does it for me.”

The benefits were immediate:

• Consistency: Every meeting had notes, not just some.
• Clarity: No guessing what was decided.
• Accountability: Action items had names attached.

His colleagues were impressed too. When Zack shared the first AI-generated notes in Slack, someone replied:
“Wow, these are clearer than the ones we used to write ourselves.”

Conclusion

In this lesson, Zack transformed raw transcripts into usable meeting outputs:

• He learned how to prompt LLMs for both summaries and action items.
• He handled long transcripts with chunking.
• He coded a script that turned a transcript into notes + JSON tasks.
• He completed an exercise with his own audio file.

Now Zack’s assistant wasn’t just reading emails and listening to meetings. It was turning information into knowledge and tasks.