Transforms raw meeting transcripts into high-fidelity, structured meeting minutes with iterative review for completeness. This skill should be used when (1) a meeting transcript is provided and meeting minutes, notes, or summaries are requested, (2) multiple versions of meeting minutes need to be merged without losing content, (3) existing minutes need to be reviewed against the original transcript for missing items, (4) transcript has anonymous speakers like "Speaker 1/2/3" that need identification. Features include: speaker identification via feature analysis (word count, speaking style, topic focus) with context.md team directory mapping, intelligent file naming from content, integration with transcript-fixer for pre-processing, evidence-based recording with speaker quotes, Mermaid diagrams for architecture discussions, multi-turn parallel generation to avoid content loss, and iterative human-in-the-loop refinement.
Standardmรครig ist der Prompt ausgewรคhlt, der zuerst die Quelle prรผft. Sie kรถnnen zu einem direkten Befehl wechseln oder eine lokale Kopie herunterladen.
Quelldateien prรผfen
Lesen Sie SKILL.md und alle von SkillsMP angezeigten Begleitdateien, bevor Sie sich fรผr eine Installation entscheiden.
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fรผgen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prรผfen und installieren.
Ein direkter Befehl รผberspringt den Prรผf-Prompt. Prรผfen Sie die Quelle, bevor Sie ihn ausfรผhren.
Transforms raw meeting transcripts into high-fidelity, structured meeting minutes with iterative review for completeness. This skill should be used when (1) a meeting transcript is provided and meeting minutes, notes, or summaries are requested, (2) multiple versions of meeting minutes need to be merged without losing content, (3) existing minutes need to be reviewed against the original transcript for missing items, (4) transcript has anonymous speakers like "Speaker 1/2/3" that need identification. Features include: speaker identification via feature analysis (word count, speaking style, topic focus) with context.md team directory mapping, intelligent file naming from content, integration with transcript-fixer for pre-processing, evidence-based recording with speaker quotes, Mermaid diagrams for architecture discussions, multi-turn parallel generation to avoid content loss, and iterative human-in-the-loop refinement.
When user provides a project context file (e.g., context.md):
Load team directory section
Match feature patterns to known team members
Cross-reference roles with speaking patterns
Context file should include:
## Team Directory
| Name | Role | Communication Style |
|------|------|---------------------|
| Alice | Backend Lead | Technical, decisive, assigns backend tasks |
| Bob | PM | Product-focused, asks requirements questions |
| Carol | TPM | Process-focused, tracks timeline/resources |
Phase C: Confirmation Before Proceeding
CRITICAL: Never silently assume speaker identity.
Present analysis summary to user:
Speaker Analysis:
- Speaker 1 โ Alice (Backend Lead) - 80% confidence based on: technical focus, task assignment pattern
- Speaker 2 โ Bob (PM) - 75% confidence based on: product questions, requirements discussion
- Speaker 3 โ Carol (TPM) - 70% confidence based on: timeline concerns, resource tracking
Please confirm or correct these mappings before I proceed.
After user confirmation, apply mappings consistently throughout the document.
Evaluate transcript quality to determine processing depth:
Scoring Criteria (1-10 scale):
Factor
Score Impact
Content volume
>10k chars: +2, 5-10k: +1, <2k: cap at 3
Filler word ratio
<5%: +2, 5-10%: +1, >10%: -1
Speaker clarity
Main speaker >80%: +1 (clear presenter)
Technical depth
High technical content: +1
Quality Tiers:
Score
Tier
Processing Approach
โฅ8
High
Full structured minutes with all sections, diagrams, quotes
5-7
Medium
Standard minutes, focus on key decisions and action items
<5
Low
Summary only - brief highlights, skip detailed transcription
Example assessment:
๐ Transcript Quality Assessment:
- Content: 41,837 chars (+2)
- Filler ratio: 3.6% (+2)
- Main speaker: 99% (+1)
- Technical depth: High (+1)
โ Quality Score: 10/10 (High)
โ Recommended: Full structured minutes with diagrams
User decision point: If quality is Low (<5), ask user:
"Transcript quality is low (็ข็ๅฏน่ฏ/ๅช้ณ่พๅค). Generate full minutes or summary only?"
Step 2: Multi-Turn Initial Generation (Critical)
A single pass will absolutely lose content. Use multi-turn generation with redundant complete passes:
Core Principle: Multiple Complete Passes + UNION Merge
Each pass generates COMPLETE minutes (all sections) from the full transcript. Multiple passes with isolated context catch different details. UNION merge consolidates all findings.
Strategy A: Sequential Multi-Pass (Complete Minutes Each Pass)
Pass 1: Read transcript โ Generate complete minutes โ Write to: <output_dir>/intermediate/version1.md
Pass 2: Fresh context โ Read transcript โ Generate complete minutes โ Write to: <output_dir>/intermediate/version2.md
Pass 3: Fresh context โ Read transcript โ Generate complete minutes โ Write to: <output_dir>/intermediate/version3.md
Merge: Read all versions โ UNION merge (consolidate duplicates) โ Write to: draft_minutes.md
Final: Compare draft against transcript โ Add any remaining omissions โ final_minutes.md
Strategy B: Parallel Multi-Agent (Complete Minutes Each Agent) - PREFERRED
MUST use the Task tool to spawn multiple subagents with isolated context, each generating complete minutes:
Implementation using Task tool:
// Launch ALL 3 subagents in PARALLEL (single message, multiple Task tool calls)
Task(subagent_type="general-purpose", prompt="Generate complete meeting minutes from transcript...", run_in_background=false) โ version1.md
Task(subagent_type="general-purpose", prompt="Generate complete meeting minutes from transcript...", run_in_background=false) โ version2.md
Task(subagent_type="general-purpose", prompt="Generate complete meeting minutes from transcript...", run_in_background=false) โ version3.md
// After all complete:
Main Agent: Read all versions โ UNION merge, consolidate duplicates โ draft_minutes.md
CRITICAL: Subagent Prompt Must Include:
Full path to transcript file
Full path to output file (version1.md, version2.md, version3.md in transcript-specific subdirectory)
Context files to load (project-specific context if provided, meeting_minutes_template.md)
Reference images/documents if provided by user
Output language requirement (match user's language preference, preserve technical terms in English)
Quote formatting requirement (see Quote Formatting Requirements section below)
Why multiple complete passes work:
Each pass independently analyzes the SAME content
Different context states catch different details (no single pass catches everything)
Pass 1 might catch decision X but miss action item Y
Pass 2 might catch action item Y but miss decision X
UNION merge captures both X and Y
Why isolated context matters:
Each pass/agent starts fresh without prior assumptions
No cross-contamination between passes
Different "perspectives" emerge naturally from context isolation
Progressive Context Offloading (Use File System)
Critical: Write each pass output to files, not conversation context.
Path Convention: All intermediate files should be created in a transcript-specific subdirectory under <output_dir>/intermediate/ to avoid conflicts between different transcripts being processed.
CRITICAL: Use transcript-specific subdirectory structure:
Sequence diagrams for data flow and API interactions
Flowcharts for process/workflow decisions
State diagrams for state machine discussions
Diagrams make minutes significantly easier for humans to review and understand
Context-first document structure - Place all reviewed artifacts (UI mockups, API docs, design images) at the TOP of the document (after metadata, before Executive Summary) to establish context before decisions; copy images to assets/<meeting-name>/ folder and embed inline using  syntax; include brief descriptions with the visuals - this creates "next level" human-readable minutes where readers understand what was discussed before reading the discussion
Speaker attribution - Correctly attribute decisions to speakers
Always use multiple passes - Single turn is guaranteed to lose content
Normalize equivalent terminology - Treat trivial variations (e.g., "backend architecture" vs "backend", "API endpoint" vs "endpoint") as equivalent; do NOT point out or highlight such differences between speakers
Single source of truth - Place each piece of information in ONE location only; avoid duplicating tables, lists, or summaries across sections (e.g., API list belongs in Discussion OR Reference, not both)
Step 3: Self-Review for Completeness
After initial generation, immediately review against transcript:
Completeness Checklist:
- [ ] All discussion topics covered?
- [ ] All decisions have supporting quotes?
- [ ] All speakers attributed correctly?
- [ ] All action items have specific owners?
- [ ] Numerical values preserved (ranges, counts)?
- [ ] Entity relationships captured?
- [ ] State machines complete (all states listed)?
If gaps found, add missing content silently without mentioning what was missed.
Step 4: Present to User for Human Review
Present the complete minutes as a draft for human review. Emphasize:
Minutes require careful line-by-line human review
Domain experts catch terminology conflicts AI may miss
Final version emerges through iterative refinement
User may:
Accept as-is (rare for complex meetings)
Request deeper review for missing content
Identify terminology issues (e.g., naming conflicts with existing systems)
Provide another AI's output for cross-comparison
Step 5: Cross-AI Comparison (Reduces Bias)
When human provides output from another AI tool (e.g., Gemini, ChatGPT, etc.):
This step is valuable because:
Different AI models have different biases - Each AI catches different details
Cross-validation - Content appearing in both outputs is likely accurate
Gap detection - Content in one but not the other reveals potential omissions
Error correction - One AI may catch factual errors the other missed (e.g., wrong date, wrong attendee name)
Comparison Process:
Read the external AI output carefully
Identify items present in external output but missing from our draft
Verify each item against original transcript before adding (don't blindly copy)
Identify items where external AI has errors (wrong facts) - note but don't copy errors
UNION merge valid new content into our draft
Document any corrections made based on cross-comparison
Example findings from cross-AI comparison:
Missing decision about API authentication method โ (add to our draft)
Missing naming convention specification โ (add to our draft)
Wrong date (2026-01-13 vs actual 2026-01-14) โ (don't copy error)
Wrong attendee name โ (don't copy error)
Missing database performance concern โ (add to parking lot)
Step 6: Iterate on Human Feedback (Critical)
When user requests deeper review ("deep review", "check again", "anything missing"):
Re-read transcript section by section
Compare each section against current minutes
Look for: entities, field names, numerical ranges, state transitions, trade-offs, deferred items
Add any omitted content
Never claim "nothing missing" without thorough section-by-section review
When user provides another version to merge:
Merge Principle: UNION, never remove
Keep ALL content from existing version
Add ALL new content from incoming version
Consolidate duplicates (don't repeat same info)
Preserve more detailed version when depth differs
Maintain logical section numbering
Aggressive Diagram Inclusion (CRITICAL)
During merge phase, MUST aggressively include ALL diagrams from ALL versions.
Diagrams are high-value content that took effort to generate. Different subagents may produce different diagrams based on what they focused on. Missing a diagram during merge is a significant loss.
Merge diagram strategy:
Inventory ALL diagrams from each version (v1, v2, v3)
Include ALL unique diagrams - don't assume a diagram is redundant
If similar diagrams exist, keep the more detailed/complete one
Check every section that could contain diagrams: Executive Summary, Discussion, API design, State machines, Data flow, etc.
Common diagram types to look for:
Sequence diagrams (data flow, API interactions)
ER diagrams (database schema, table relationships)
State diagrams (state machines, status transitions)
Flowcharts (decision flows, process workflows)
Component diagrams (system architecture)
Example: Missed diagram from v3
If v3 has a flowchart for "Status Query Mechanism" but v1/v2 don't have it, that flowchart MUST appear in the merged output. Don't assume it's covered by other diagrams.
Output Language
Primary: Match the language of the transcript (or user's preference if specified)
Preserve in English: Technical terms, entity names, abbreviations (standard practice)
Diagrams elevate meeting minutes beyond pure text. They make complex discussions immediately understandable for human reviewers. Always look for opportunities to add visual diagrams.
When to Use Diagrams:
Data flow discussions โ Sequence diagram
Database schema discussions โ ER diagram
Process/workflow decisions โ Flowchart
State machine discussions โ State diagram
System architecture โ Component diagram
Example: Data Flow (Sequence Diagram)
sequenceDiagram
participant FE as Frontend
participant BE as Backend
participant SVC as External Service
participant DB as Database
FE->>BE: Click "Submit Order"
BE->>SVC: POST /process (send data)
SVC-->>BE: Return {status}
BE->>DB: Save result
BE-->>FE: Return success
Example: Database Schema (ER Diagram)
erDiagram
ORDER ||--o{ ORDER_ITEM : "1:N"
ORDER {
uuid id PK
string customer_name
decimal total_amount
}
ORDER_ITEM {
uuid id PK
uuid order_id FK
int quantity
}
Example: Version Switching (Workflow Diagram)
sequenceDiagram
participant User
participant System
Note over System: Current: V2 Active
User->>System: Create V3 (inactive)
User->>System: Set V2 inactive
User->>System: Set V3 active
Note over System: New: V3 Active
Quote Formatting Requirements (CRITICAL)
Quotes MUST use proper markdown blockquote format on separate lines:
โ WRONG: Inline quote format
***Quote:** > "This is wrong" - **Speaker**
โ CORRECT: Blockquote on separate lines
***Quote:**
> "This is the correct format" - **Speaker**
โ CORRECT: Multiple quotes
***Quote:**
> "First quote from the discussion" - **Speaker1**
> "Second quote supporting the same decision" - **Speaker2**
Key formatting rules:
* **Quote:** on its own line (no quote content on this line)
Blank line NOT needed after * **Quote:**
Quote content indented with 2 spaces, then > prefix
Speaker attribution at end of quote line: - **SpeakerName**
Multiple quotes use same indentation, each on its own line
Technical Decisions โ Decision Block
### 2.X [Category] Decision Title***Decision:** Specific decision made
***Logic:** * Reasoning point 1
* Reasoning point 2
***Quote:**
> "Exact quote from transcript" - **Speaker Name**
Deferred Items โ Parking Lot
Items with keywords like "defer to later", "Phase 2", "not in MVP" go to Parking Lot with context.
Human-in-the-Loop Iteration (Essential)
Meeting minutes are not one-shot outputs. High-quality minutes emerge through multiple review cycles:
Why Human Review is Critical
Terminology conflicts: Humans know existing system naming (e.g., "Note" already means comments in the existing system)
Domain context: Humans catch when a term could be confused with another (e.g., "UserProfile" vs "Account")
Organizational knowledge: Humans know team conventions and prior decisions
Completeness gaps: Humans can request "deep review" review when something feels missing
Example Iteration Pattern
Round 1: Initial generation
โโ Human review: "Check original transcript for missing items"
Round 2: Deep transcript review, add omitted content
โโ Human review: "UserProfile conflicts with existing Account entity naming"
Round 3: Update terminology to use "CustomerProfile" instead
โโ Human review: "Note field conflicts with existing Comment system"
Round 4: Update to use "Annotation" instead of "Note"
โโ Human approval: Final version ready
Key Principle
The AI generates the first draft; humans refine to the final version. Never assume the first output is complete or uses correct terminology. Always encourage human review and be ready for multiple iteration cycles.
Anti-Patterns
โ Single-pass generation - One turn through transcript will absolutely lose content
โ Divided sections without overlap - Each pass must cover FULL transcript, not split by sections
โ Narrow-focused passes - Each pass must generate COMPLETE minutes (all sections), not just one section type (wastes tokens, causes bias)
โ Generic summaries without supporting quotes
โ Action items assigned to "team" instead of specific person
โ Missing numerical values (priorities, ranges, state counts)
โ State machines with incomplete states
โ Circular debate transcribed verbatim instead of summarized
โ Removing content during multi-version merge
โ Claiming "nothing missing" without section-by-section review
โ Treating first draft as final without human review
โ Using terminology without checking for conflicts with existing systems
โ Shared context between subagents (causes cross-contamination and missed content)
โ Keeping all intermediate outputs in conversation context (causes token overflow, use file system)
โ Pure text minutes without diagrams - Architecture/schema discussions deserve visual representation
โ Deleting intermediate files after merge - Preserve for human review and debugging
โ Blindly copying external AI output - Always verify against transcript before merging
โ Ignoring cross-AI comparison opportunity - Different AI models catch different details
โ Sequential subagent execution - MUST launch v1, v2, v3 subagents in PARALLEL using multiple Task tool calls in a single message
โ Flat intermediate directory - MUST use transcript-specific subdirectory intermediate/<transcript-name>/ to avoid conflicts
โ Inline quote formatting - Quotes MUST use blockquote format on separate lines, not inline > "quote"
โ Omitting diagrams during merge - MUST aggressively include ALL diagrams from ALL versions, even if they seem similar
โ Highlighting trivial terminology variations - Do NOT point out differences like "backend architecture" vs "backend" or "API" vs "endpoint" between speakers; these are equivalent terms and highlighting such differences is disrespectful
โ Duplicate content across sections - Do NOT repeat the same information in multiple sections (e.g., API endpoint table in both "Discussion" and "Reference"); place content in ONE authoritative location and reference it if needed
โ Creating non-existent links - Do NOT create markdown links to files that don't exist in the repo (e.g., [doc.md](reviewed-document)); use plain text for external/local documents not in the repository
โ Losing content during consolidation - When moving or consolidating sections, verify ALL bullet points and details are preserved; never summarize away specific details like "supports batch operations" or "button triggers auto-save"
โ Appending domain details to role titles - Use ONLY the Role column from Team Directory for speaker attribution (e.g., "Backend", "Frontend", "TPM"); do NOT append specializations like "Backend, Infrastructure" or "Backend, Business Logic" - all team members with the same role should have identical attribution
