Meeting Notes Summarizer

Transforms raw, messy meeting notes into structured summaries with clearly extracted action items, key decisions, assigned owners, and deadlines. This skill takes your stream-of-consciousness notes, voice transcription dumps, or scattered bullet points and produces clean, shareable meeting minutes. Works with output formats for Notion, Confluence, Google Docs, Slack, and Microsoft Teams so you can distribute summaries instantly after any meeting.

Supported Platforms & Integrations

Platform	Integration Type	Features
Notion	Page format	Database-compatible with action item tracking
Confluence	Wiki format	Team knowledge base with meeting history
Google Docs	Document format	Shareable docs with comment-ready structure
Slack	Channel post	Summary formatted for channel distribution
Microsoft Teams	Message format	Teams-compatible meeting recap posts
Jira / Linear	Task export	Action items exported as tickets with assignees

When to Use This Skill

• Use this after any meeting where you took rough notes and need to share a clean summary

• Use this when processing voice transcription dumps from Otter.ai, Rev, or similar tools

• Use this when you need to extract action items from a long, rambling discussion

• Use this when documenting decisions made in a meeting for future reference

• Use this when you missed a meeting and someone sends you their raw notes to parse

• Use this when preparing recurring meeting agendas based on previous meeting action items

• Consider alternatives when you need real-time transcription during a meeting (use Otter.ai or Fireflies)

• Consider alternatives when creating formal board meeting minutes with legal requirements

• Consider alternatives when summarizing recorded video meetings (use a video summarizer)

Quick Start

Copy
# meeting-notes-config.yml
meeting:
  title: "Q2 Planning Sprint Review"
  date: "2026-03-14"
  attendees:
    - "Sarah (PM)"
    - "Alex (Eng Lead)"
    - "Jordan (Design)"
    - "Mike (QA)"
  duration: "45 min"
  output_format: "notion"

First run example:

> Summarize these meeting notes:
"talked about Q2 roadmap, sarah wants to prioritize the checkout redesign, alex says 3 sprints needed, jordan showed mockups everyone liked them but mike raised concerns about mobile perf, decided to do checkout first then dashboard, alex will create jira epics by friday, jordan needs to finalize mobile mockups by wednesday, mike will set up perf testing environment..."

Meeting Summary: Q2 Planning Sprint Review
Date: March 14, 2026 | Duration: 45 min

Key Decisions:
1. Checkout redesign will be prioritized over dashboard in Q2
2. Checkout estimated at 3 sprints (6 weeks)
3. Jordan's desktop mockups approved by team

Action Items:
| # | Action | Owner | Deadline |
|---|--------|-------|----------|
| 1 | Create Jira epics for checkout redesign | Alex | Friday Mar 16 |
| 2 | Finalize mobile mockups | Jordan | Wednesday Mar 19 |
| 3 | Set up performance testing environment | Mike | TBD |

Open Questions:
- Mobile performance concerns raised by Mike — needs investigation
- Dashboard timeline not yet determined (depends on checkout completion)

Next Steps:
- Reconvene after checkout epics are created to review sprint planning

Advanced Configuration

Copy
# Output customization
output:
  format: "notion"
  sections:
    - "summary"
    - "decisions"
    - "action-items"
    - "open-questions"
    - "parking-lot"
  action_item_format: "table"
  include_attendee_contributions: true

# Processing preferences
processing:
  input_type: "raw-notes"
  extract_sentiment: false
  flag_risks: true
  link_to_previous: true

Parameter	Type	Default	Description
output_format	string	"markdown"	Options: markdown, notion, confluence, slack, teams
input_type	string	"raw-notes"	Options: raw-notes, transcription, bullet-points, audio-summary
sections	array	[4 defaults]	Which sections to include in the summary
action_item_format	string	"table"	Options: table, checklist, numbered-list
include_owners	boolean	true	Extract and assign owners to action items
include_deadlines	boolean	true	Extract or suggest deadlines for action items
summary_length	string	"concise"	Options: one-liner, concise, detailed
flag_risks	boolean	false	Highlight risks or concerns raised during meeting
link_previous	boolean	false	Reference previous meeting notes for continuity
tone	string	"neutral"	Options: neutral, executive, casual
confidential_filter	boolean	false	Flag and optionally remove sensitive discussions

Core Concepts

Concept	Description
Signal Extraction	Pulling decisions and actions from conversational noise
Owner Assignment	Identifying who is responsible for each action from context clues
Deadline Inference	Deriving deadlines from phrases like "by end of week" or "before next sprint"
Decision Documentation	Recording not just what was decided but why and what alternatives were rejected
Parking Lot	Capturing topics raised but not resolved for future discussion

+------------------+     +-------------------+     +------------------+
| Raw Notes Input  | --> | Signal Extractor  | --> | Categorizer      |
| (messy text,     |     | (decisions, asks  |     | (decisions, AIs  |
|  transcription)  |     |  risks, ideas)    |     |  questions, FYIs)|
+------------------+     +-------------------+     +------------------+
                                                          |
                                                          v
+------------------+     +-------------------+     +------------------+
| Formatted Output | <-- | Platform Adapter  | <-- | Structure Builder|
| (notion, slack,  |     | (formatting for   |     | (sections, table |
|  confluence)     |     |  target platform) |     |  owners, dates)  |
+------------------+     +-------------------+     +------------------+

Workflow Examples

Scenario 1: Engineering Standup Summary

Input: "standup notes — jake: finished auth PR, waiting on review from priya. priya: stuck on caching bug, needs help. sarah: started dashboard api, will have endpoints ready by tomorrow. blocked: priya needs pair programming session. jake can help after lunch."
Output:
Daily Standup — March 14, 2026

Progress:
- Jake: Auth PR complete, awaiting code review
- Sarah: Dashboard API in progress, endpoints expected by EOD tomorrow

Blockers:
- Priya: Caching bug unresolved — needs pair programming support

Action Items:
| Action | Owner | When |
|--------|-------|------|
| Review Jake's auth PR | Priya | Today |
| Pair program on caching bug with Priya | Jake | Today after lunch |
| Complete dashboard API endpoints | Sarah | Tomorrow EOD |

Scenario 2: Executive Strategy Meeting

Input: "CEO discussed entering European market. CFO concerned about GDPR compliance costs — estimates $200K. CTO says we need 3 months to make the platform GDPR compliant. VP Sales says EU pipeline is $2M. Decided to proceed with EU expansion. Legal team will lead GDPR audit. Target launch: Q3 2026. CEO wants weekly updates starting next Monday."
Output:
Executive Strategy Meeting — EU Expansion
Date: March 14, 2026

Executive Summary:
Decision made to proceed with European market expansion targeting Q3 2026 launch, with an estimated $200K GDPR compliance investment against a $2M EU sales pipeline.

Key Decisions:
1. EU expansion approved — proceed immediately
2. GDPR compliance is the critical path (3-month estimate)
3. Legal team designated as GDPR audit lead

Financial Context:
- Compliance cost estimate: $200K
- EU pipeline value: $2M (10x ROI potential)

Action Items:
| # | Action | Owner | Deadline |
|---|--------|-------|----------|
| 1 | Initiate GDPR compliance audit | Legal (lead) + CTO | Immediately |
| 2 | Begin weekly EU expansion updates | All execs | Next Monday |
| 3 | Develop EU go-to-market plan | VP Sales | TBD |

Risk Flags:
- GDPR compliance timeline (3 months) is tight for Q3 launch — limited buffer
- Compliance cost estimate may increase pending audit findings

Scenario 3: Otter.ai Transcription Cleanup

Input: Long, messy transcription with filler words, crosstalk, and unclear speakers: "um so like I think we should probably um look at the, the pricing page because conversions dropped like 15% last month and uh Sarah you had some ideas right? yeah so I was thinking we could A/B test the pricing tiers..."
Output:
Clean Summary:
- Pricing page conversion dropped 15% last month
- Sarah proposed A/B testing pricing tiers
- Decision: Run A/B test on pricing page for 2 weeks
- Owner: Sarah (design variants), Mike (implementation)
[All filler words, crosstalk, and fragments cleaned up]

Best Practices

Take notes with extraction in mind. When taking notes during a meeting, use simple markers: prefix decisions with "DECIDED:", action items with "AI:", and questions with "Q:". The skill can process unmarked notes, but marked notes produce faster, more accurate extraction. Even rough markers like "todo" or "action" help significantly.

Distribute summaries within 2 hours. Meeting summaries lose value rapidly. Within 2 hours, people still remember the discussion and can correct errors. After 24 hours, memories have shifted and the summary becomes the de facto record whether it is accurate or not.

Include rejected alternatives in decision documentation. Recording that the team decided to build feature X is useful. Recording that they considered options X, Y, and Z, and chose X because of reasons A and B, is invaluable. Three months later when someone asks "why didn't we just do Y?", the meeting notes answer the question without re-litigation.

Assign every action item an explicit owner. "We should look into this" is not an action item — it is a wish. Every action item needs a single person's name attached. If the meeting did not assign one, the skill flags unowned items so you can follow up.

Create a parking lot for tangents. Not every discussion point needs resolution in the current meeting. The parking lot section captures topics that were raised but deferred — "Mike mentioned we should audit our AWS costs" — so they are not lost but also do not derail the current agenda. Review the parking lot at the start of the next meeting to decide what to address.

Common Issues

Problem: Raw notes are too messy for accurate extraction. The skill handles messy input well, but extremely fragmented notes may produce inaccurate summaries. If your notes are just single words or abbreviations, add brief context when pasting them in: "checkout - alex - 3 sprints" benefits from "checkout redesign project discussed, alex estimated 3 sprints needed." Even one additional word of context per line dramatically improves extraction accuracy.

Problem: Cannot determine who owns an action item from the notes. When the skill cannot confidently assign an owner, it marks the item with "[OWNER TBD]" rather than guessing incorrectly. Review these items after generation and assign owners yourself. Send a quick message to the relevant person: "From today's meeting — can you own the performance testing setup? I have you tentatively assigned."

Problem: Multiple meetings blend together in notes. If you attend back-to-back meetings and your notes run together, add a clear separator between meetings before processing. The skill processes one meeting at a time. Using separate notes files or adding "--- NEW MEETING ---" markers helps.

Privacy & Data Handling

• Local processing: All note summarization, action item extraction, and formatting happens locally within your Claude Code session. No meeting content is sent to any external service.
• Data retention: Meeting notes and generated summaries exist only during the active session. Save summaries to your preferred platform (Notion, Confluence, Google Docs) manually.
• Export options: Export as markdown, Notion-compatible format, Confluence wiki markup, Slack message format, or structured JSON. Action items can be exported as Jira or Linear ticket formats.
• Sensitive data: The skill does not access your calendar, video conferencing recordings, or transcription services. All content is pasted in by you. Use confidential_filter: true to flag and optionally redact sensitive discussions before sharing.
• Sharing control: You control exactly which sections of the summary are shared and with whom. The skill can generate different versions — a detailed version for attendees and a high-level version for stakeholders — from the same source notes.