Skip to content
audio-transcriber Β· agentic-awesome-skills Β· Flowy
Transform audio recordings into professional Markdown documentation with intelligent summaries using LLM integration
One skill from agentic-awesome-skills .
$ npx -y skills add sickn33/agentic-awesome-skills --skill audio-transcriber --agent claude-codeInstalls just this skill. Get the whole plugin for auto-invocation.
β‘ How it fires
How this skill gets triggered: by you, by Claude, or both.
Fires itself Claude auto-loads it when your prompt matches the work. You can call it Invoke it directly when you want it. Slash command /audio-transcriberποΈ Context preview
The summary Claude sees to decide when to auto-load this skill.
Transform audio recordings into professional Markdown documentation with intelligent summaries using LLM integration π¦ Ships with agentic-awesome-skills
</> SKILL.md
audio-transcriber.SKILL.md
---
name : audio-transcriber
description : "Transform audio recordings into professional Markdown documentation with intelligent summaries using LLM integration"
category : content
risk : safe
source : community
tags : "[audio, transcription, whisper, meeting-minutes, speech-to-text]"
date_added : "2026-02-27"
---
## Purpose
This skill automates audio-to-text transcription with professional Markdown output, extracting rich technical metadata (speakers, timestamps, language, file size, duration) and generating structured meeting minutes and executive summaries. It uses Faster-Whisper or Whisper with zero configuration, working universally across projects without hardcoded paths or API keys.
Inspired by tools like Plaud, this skill transforms raw audio recordings into actionable documentation, making it ideal for meetings, interviews, lectures, and content analysis.
## When to Use
Invoke this skill when:
- User needs to transcribe audio/video files to text
- User wants meeting minutes automatically generated from recordings
- User requires speaker identification (diarization) in conversations
- User needs subtitles/captions (SRT, VTT formats)
- User wants executive summaries of long audio content
- User asks variations of "transcribe this audio", "convert audio to text", "generate meeting notes from recording"
Flowy AI Flows that just work. Hand-picked Claude Code plugins that fire the right skill as you prompt.
- User has audio files in common formats (MP3, WAV, M4A, OGG, FLAC, WEBM)
## Workflow
### Step 0: Discovery (Auto-detect Transcription Tools)
**Objective:** Identify available transcription engines without user configuration.
**Actions:**
Run detection commands to find installed tools:
```bash
# Check for Faster-Whisper (preferred - 4-5x faster)
if python3 -c "import faster_whisper" 2>/dev/null; then
TRANSCRIBER="faster-whisper"
echo "β
Faster-Whisper detected (optimized)"
# Fallback to original Whisper
elif python3 -c "import whisper" 2>/dev/null; then
TRANSCRIBER="whisper"
echo "β
OpenAI Whisper detected"
else
TRANSCRIBER="none"
echo "β οΈ No transcription tool found"
fi
# Check for ffmpeg (audio format conversion)
if command -v ffmpeg &>/dev/null; then
echo "β
ffmpeg available (format conversion enabled)"
else
echo "βΉοΈ ffmpeg not found (limited format support)"
fi
```
**If no transcriber found:**
Offer automatic installation using the provided script:
```bash
echo "β οΈ No transcription tool found"
echo ""
echo "π§ Auto-install dependencies? (Recommended)"
read -p "Run installation script? [Y/n]: " AUTO_INSTALL
if [[ ! "$AUTO_INSTALL" =~ ^[Nn] ]]; then
# Get skill directory (works for both repo and symlinked installations)
SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
# Run installation script
if [[ -f "$SKILL_DIR/scripts/install-requirements.sh" ]]; then
bash "$SKILL_DIR/scripts/install-requirements.sh"
else
echo "β Installation script not found"
echo ""
echo "π¦ Manual installation:"
echo " pip install faster-whisper # Recommended"
echo " pip install openai-whisper # Alternative"
echo " brew install ffmpeg # Optional (macOS)"
exit 1
fi
# Verify installation succeeded
if python3 -c "import faster_whisper" 2>/dev/null || python3 -c "import whisper" 2>/dev/null; then
echo "β
Installation successful! Proceeding with transcription..."
else
echo "β Installation failed. Please install manually."
exit 1
fi
else
echo ""
echo "π¦ Manual installation required:"
echo ""
echo "Recommended (fastest):"
echo " pip install faster-whisper"
echo ""
echo "Alternative (original):"
echo " pip install openai-whisper"
echo ""
echo "Optional (format conversion):"
echo " brew install ffmpeg # macOS"
echo " apt install ffmpeg # Linux"
echo ""
exit 1
fi
```
This ensures users can install dependencies with one confirmation, or opt for manual installation if preferred.
**If transcriber found:**
Proceed to Step 0b (CLI Detection).
### Step 1: Validate Audio File
**Objective:** Verify file exists, check format, and extract metadata.
**Actions:**
1. **Accept file path or URL** from user:
- Local file: `meeting.mp3`
- URL: `https://example.com/audio.mp3` (download to temp directory)
2. **Verify file exists:**
```bash
if [[ ! -f "$AUDIO_FILE" ]]; then
echo "β File not found: $AUDIO_FILE"
exit 1
fi
```
3. **Extract metadata** using ffprobe or file utilities:
```bash
# Get file size
FILE_SIZE=$(du -h "$AUDIO_FILE" | cut -f1)
# Get duration and format using ffprobe
DURATION=$(ffprobe -v error -show_entries format=duration \
-of default=noprint_wrappers=1:nokey=1 "$AUDIO_FILE" 2>/dev/null)
FORMAT=$(ffprobe -v error -select_streams a:0 -show_entries \
stream=codec_name -of default=noprint_wrappers=1:nokey=1 "$AUDIO_FILE" 2>/dev/null)
# Convert duration to HH:MM:SS
DURATION_HMS=$(date -u -r "$DURATION" +%H:%M:%S 2>/dev/null || echo "Unknown")
```
4. **Check file size** (warn if large for cloud APIs):
```bash
SIZE_MB=$(du -m "$AUDIO_FILE" | cut -f1)
if [[ $SIZE_MB -gt 25 ]]; then
echo "β οΈ Large file ($FILE_SIZE) - processing may take several minutes"
fi
```
5. **Validate format** (supported: MP3, WAV, M4A, OGG, FLAC, WEBM):
```bash
EXTENSION="${AUDIO_FILE##*.}"
SUPPORTED_FORMATS=("mp3" "wav" "m4a" "ogg" "flac" "webm" "mp4")
if [[ ! " ${SUPPORTED_FORMATS[@]} " =~ " ${EXTENSION,,} " ]]; then
echo "β οΈ Unsupported format: $EXTENSION"
if command -v ffmpeg &>/dev/null; then
echo "π Converting to WAV..."
ffmpeg -i "$AUDIO_FILE" -ar 16000 "${AUDIO_FILE%.*}.wav" -y
AUDIO_FILE="${AUDIO_FILE%.*}.wav"
else
echo "β Install ffmpeg to convert formats: brew install ffmpeg"
exit 1
fi
fi
```
### Step 3: Generate Markdown Output
**Objective:** Create structured Markdown with metadata, transcription, meeting minutes, and summary.
**Output Template:**
```markdown
# Audio Transcription Report
## π Metadata
| Field | Value |
|-------|-------|
| **File Name** | {filename} |
| **File Size** | {file_size} |
| **Duration** | {duration_hms} |
| **Language** | {language} ({language_code}) |
| **Processed Date** | {process_date} |
| **Speakers Identified** | {num_speakers} |
| **Transcription Engine** | {engine} (model: {model}) |
## π Meeting Minutes
### Participants
- {speaker_1}
- {speaker_2}
- ...
### Topics Discussed
1. **{topic_1}** ({timestamp})
- {key_point_1}
- {key_point_2}
2. **{topic_2}** ({timestamp})
- {key_point_1}
### Decisions Made
- β
{decision_1}
- β
{decision_2}
### Action Items
- [ ] **{action_1}** - Assigned to: {speaker} - Due: {date_if_mentioned}
- [ ] **{action_2}** - Assigned to: {speaker}
*Generated by audio-transcriber skill v1.0.0*
*Transcription engine: {engine} | Processing time: {elapsed_time}s*
```
**Implementation:**
Use Python or bash with AI model (Claude/GPT) for intelligent summarization:
```python
def generate_meeting_minutes(segments):
"""Extract topics, decisions, action items from transcription."""
# Group segments by topic (simple clustering by timestamps)
topics = cluster_by_topic(segments)
# Identify action items (keywords: "should", "will", "need to", "action")
action_items = extract_action_items(segments)
# Identify decisions (keywords: "decided", "agreed", "approved")
decisions = extract_decisions(segments)
return {
"topics": topics,
"decisions": decisions,
"action_items": action_items
}
def generate_summary(segments, max_paragraphs=5):
"""Create executive summary using AI (Claude/GPT via API or local model)."""
full_text = " ".join([s["text"] for s in segments])
# Use Chain of Density approach (from prompt-engineer frameworks)
summary_prompt = f"""
Summarize the following transcription in {max_paragraphs} concise paragraphs.
Focus on key topics, decisions, and action items.
Transcription:
{full_text}
"""
# Call AI model (placeholder - user can integrate Claude API or use local model)
summary = call_ai_model(summary_prompt)
return summary
```
**Output file naming:**
```bash
# v1.1.0: Use timestamp para evitar sobrescrever
TIMESTAMP=$(date +%Y%m%d-%H%M%S)
TRANSCRIPT_FILE="transcript-${TIMESTAMP}.md"
ATA_FILE="ata-${TIMESTAMP}.md"
echo "$TRANSCRIPT_CONTENT" > "$TRANSCRIPT_FILE"
echo "β
Transcript salvo: $TRANSCRIPT_FILE"
if [[ -n "$ATA_CONTENT" ]]; then
echo "$ATA_CONTENT" > "$ATA_FILE"
echo "β
Ata salva: $ATA_FILE"
fi
```
#### **SCENARIO A: User Provided Custom Prompt**
**Workflow:**
1. **Display user's prompt:**
```
π Prompt fornecido pelo usuΓ‘rio:
ββββββββββββββββββββββββββββββββββββ
β [User's prompt preview] β
ββββββββββββββββββββββββββββββββββββ
```
2. **Automatically improve with prompt-engineer (if available):**
```bash
π§ Melhorando prompt com prompt-engineer...
[Invokes: gh copilot -p "melhore este prompt: {user_prompt}"]
```
3. **Show both versions:**
```
β¨ VersΓ£o melhorada:
ββββββββββββββββββββββββββββββββββββ
β Role: VocΓͺ Γ© um documentador... β
β Instructions: Transforme... β
β Steps: 1) ... 2) ... β
β End Goal: ... β
ββββββββββββββββββββββββββββββββββββ
π VersΓ£o original:
ββββββββββββββββββββββββββββββββββββ
β [User's original prompt] β
ββββββββββββββββββββββββββββββββββββ
```
4. **Ask which to use:**
```bash
π‘ Usar versΓ£o melhorada? [s/n] (default: s):
```
5. **Process with selected prompt:**
- If "s": use improved
- If "n": use original
#### **LLM Processing (Both Scenarios)**
Once prompt is finalized:
```python
from rich.progress import Progress, SpinnerColumn, TextColumn
def process_with_llm(transcript, prompt, cli_tool='claude'):
full_prompt = f"{prompt}\n\n---\n\nTranscrição:\n\n{transcript}"
with Progress(
SpinnerColumn(),
TextColumn("[progress.description]{task.description}"),
transient=True
) as progress:
progress.add_task(
description=f"π€ Processando com {cli_tool}...",
total=None
)
if cli_tool == 'claude':
result = subprocess.run(
['claude', '-'],
input=full_prompt,
capture_output=True,
text=True,
timeout=300 # 5 minutes
)
elif cli_tool == 'gh-copilot':
result = subprocess.run(
['gh', 'copilot', 'suggest', '-t', 'shell', full_prompt],
capture_output=True,
text=True,
timeout=300
)
if result.returncode == 0:
return result.stdout.strip()
else:
return None
```
**Progress output:**
```
π€ Processando com claude... β
[After completion:]
β
Ata gerada com sucesso!
```
#### **Final Output**
**Success (both files):**
```bash
πΎ Salvando arquivos...
β
Arquivos criados:
- transcript-20260203-023045.md (transcript puro)
- ata-20260203-023045.md (processado com LLM)
π§Ή Removidos arquivos temporΓ‘rios: metadata.json, transcription.json
β
ConcluΓdo! Tempo total: 3m 45s
```
**Transcript only (user declined LLM):**
```bash
πΎ Salvando arquivos...
β
Arquivo criado:
- transcript-20260203-023045.md
βΉοΈ Ata nΓ£o gerada (processamento LLM recusado pelo usuΓ‘rio)
π§Ή Removidos arquivos temporΓ‘rios: metadata.json, transcription.json
β
ConcluΓdo!
```
### Step 5: Display Results Summary
**Objective:** Show completion status and next steps.
**Output:**
```bash
echo ""
echo "β
Transcription Complete!"
echo ""
echo "π Results:"
echo " File: $OUTPUT_FILE"
echo " Language: $LANGUAGE"
echo " Duration: $DURATION_HMS"
echo " Speakers: $NUM_SPEAKERS"
echo " Words: $WORD_COUNT"
echo " Processing time: ${ELAPSED_TIME}s"
echo ""
echo "π Generated:"
echo " - $OUTPUT_FILE (Markdown report)"
[if alternative formats:]
echo " - ${OUTPUT_FILE%.*}.srt (Subtitles)"
echo " - ${OUTPUT_FILE%.*}.json (Structured data)"
echo ""
echo "π― Next steps:"
echo " 1. Review meeting minutes and action items"
echo " 2. Share report with participants"
echo " 3. Track action items to completion"
```
## Example Usage
### **Example 1: Basic Transcription**
**User Input:**
```bash
copilot> transcribe audio to markdown: meeting-2026-02-02.mp3
```
**Skill Output:**
```bash
β
Faster-Whisper detected (optimized)
β
ffmpeg available (format conversion enabled)
π File: meeting-2026-02-02.mp3
π Size: 12.3 MB
β±οΈ Duration: 00:45:32
ποΈ Processing...
[ββββββββββββββββββββ] 100%
β
Language detected: Portuguese (pt-BR)
π₯ Speakers identified: 4
π Generating Markdown output...
β
Transcription Complete!
π Results:
File: meeting-2026-02-02.md
Language: pt-BR
Duration: 00:45:32
Speakers: 4
Words: 6,842
Processing time: 127s
π Generated:
- meeting-2026-02-02.md (Markdown report)
π― Next steps:
1. Review meeting minutes and action items
2. Share report with participants
3. Track action items to completion
```
### **Example 3: Batch Processing**
**User Input:**
```bash
copilot> transcreva estes Γ‘udios: recordings/*.mp3
```
**Skill Output:**
```bash
π¦ Batch mode: 5 files found
1. team-standup.mp3
2. client-call.mp3
3. brainstorm-session.mp3
4. product-demo.mp3
5. retrospective.mp3
ποΈ Processing batch...
[1/5] team-standup.mp3 β
(2m 34s)
[2/5] client-call.mp3 β
(15m 12s)
[3/5] brainstorm-session.mp3 β
(8m 47s)
[4/5] product-demo.mp3 β
(22m 03s)
[5/5] retrospective.mp3 β
(11m 28s)
β
Batch Complete!
π Generated 5 Markdown reports
β±οΈ Total processing time: 6m 15s
```
### **Example 5: Large File Warning**
**User Input:**
```bash
copilot> transcribe audio to markdown: conference-keynote.mp3
```
**Skill Output:**
```bash
β
Faster-Whisper detected (optimized)
π File: conference-keynote.mp3
π Size: 87.2 MB
β±οΈ Duration: 02:15:47
β οΈ Large file (87.2 MB) - processing may take several minutes
Continue? [Y/n]:
```
**User:** `Y`
```bash
ποΈ Processing... (this may take 10-15 minutes)
[ββββββββββββββββββββ] 20% - Estimated time remaining: 12m
```
This skill is **platform-agnostic** and works in any terminal context where GitHub Copilot CLI is available. It does not depend on specific project configurations or external APIs, following the zero-configuration philosophy.
## Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.
Β© 2026 Flowy Β· Free and open source
Built for Claude Code Β· Not affiliated with Anthropic
