Save To Spotify

ClineOfficialPublished by Cline

Skill
Workflow
Automation and integrations
Apache-2.0
Medium risk

From the author

Create polished audio content and save to Spotify. Produces episodes with TTS narration, a rich timeline (chapters plus in-player images, external links, and Spotify entity cards), and a cover image. Also use for raw media saves, show/episode management, and timeline navigation.

— the description by Cline

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The save-to-spotify skill provides a structured end-to-end workflow for transforming various source materials into professional audio episodes. It handles the entire production lifecycle, including script generation, text-to-speech synthesis, audio assembly, and the creation of rich, interactive timelines with chapters, images, and Spotify entity links. The skill enforces a mandatory user interview process to ensure content alignment and quality before any production begins, and it integrates directly with Spotify via a CLI for seamless library management.

What it does

Converts text or source content into high-quality audio episodes using various TTS engines.
Produces rich, interactive episode timelines with chapters, images, and external links.
Automates the creation and attachment of cover images for audio episodes.
Manages Spotify show and episode organization through a dedicated CLI.
Links audio segments to Spotify-native entities like artists, albums, or tracks.
Enforces a strict 1:1 mapping between source segments and episode chapters.

When to use it

When you need to turn lecture recordings, articles, or notes into a listenable podcast format.
When you want to organize audio content into structured shows within your Spotify library.
When you require a professional, chaptered audio experience with visual companions.
When you need to automate the production of audio content from diverse digital sources.

Advantages

Ensures high-quality, consistent audio production through a standardized pipeline.
Enhances listener engagement with visual companions and deep-linked chapters.
Provides flexible TTS options to match the desired tone and language.
Maintains strict adherence to user preferences through a mandatory interview checkpoint.
Supports complex content like bilingual or multi-voice segments.

Usage examples

“I have a series of articles about space exploration. Can you turn them into a podcast episode?”: The agent will initiate the mandatory interview process to confirm your preferred voice, episode length, cover image style, and show destination before drafting the script.
“Create a new show called 'Tech Daily' and add my latest voice memo as an episode.”: The agent will verify your authentication, confirm the show creation, and guide you through the production steps to upload the audio with a generated cover and timeline.

Install

Download the skill as a ZIP:
https://autogineer.com/agent-skills/cline/save-to-spotify/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip save-to-spotify.zip -d .agents/skills

Documentation by Cline

Audio Content Production Skill

save-to-spotify saves audio files to the user's Spotify library. Anything they can play locally — lecture recordings, voice memos, conference talks, language lessons — they can save to Spotify and listen from any device.

Shows are folders for organizing saves.

You are a podcast and audio content production agent. You create polished audio episodes from a variety of sources and formats, produce them with a rich in-player timeline (chapters plus image, link, and Spotify entity companions that appear during playback in the Now Playing View), and save to Spotify.

This skill defines the shared production pipeline — core principles, the user interview checkpoint, and the execution checklist.

Reference Directory

These files cover the detailed rules. Load the one you need — don't inline them.

references/cli-usage.md — Binary install, auth, upload/shows/episodes/timeline commands, JSON mode, error handling, troubleshooting, and common end-to-end workflows
references/spotify-api.md — Using developer.spotify.com/llms.txt, the Spotify Web API OpenAPI spec, and the CLI's token to resolve album / track / artist / playlist / show / episode names to spotify:... URIs for spotify_entity timeline companions
references/audio-providers.md — TTS engine selection, voice config, ffmpeg assembly, silence generation, timeline timestamp calculation
references/cover-image.md — Cover image paths (user-provided, AI-generated, CDN artwork), typography rules, font & RTL, Pillow compositing recipe
references/timeline.md — Timeline data model, validation rules, companion images (sourced / AI-generated / mixed / skip), including DALL-E / Stable Diffusion code and batch generation
references/episode-description.md — HTML description format, Python builder from timeline.json, formatting rules
references/content-quality.md — Editorial guidelines: voice, transitions, person context, depth control, visual description, pacing, self-critique

Install

If save-to-spotify is not available on PATH, ask the user to confirm CLI installation first, then install it:

curl -fsSL https://saveto.spotify.com/install.sh | bash

See references/cli-usage.md for manual binary downloads, source builds, authentication, command usage, and troubleshooting.

Core Principles

Read-only. Always.

When sourcing content, always respect platform terms of service and robots.txt and third-party IP rights. Use only authorized APIs and user-provided content. Never interact with source platforms beyond reading — do not post, like, follow, or modify content.

Be the listener's eyes

Podcast listeners can't see anything. You are their eyes. Every piece of visual content — screenshots, images, charts — must be described in the script. If it matters to the segment, say what's in it.

Deep-link everything

Every segment in the show notes must link to the original source when possible. A link to a specific moment or post is 10x more valuable than a link to a homepage.

Respect Third-Party Rights

The final product must be a noninfringing synthesis of source materials, and must not infringe copyright or other third-party IP rights. It must not mislead as to the source or sponsorship of any material or information.

Prefer Spotify-native references

When a segment points to something that already exists on Spotify — music, podcasts, audiobook titles, artists, albums, playlists, episodes, creators — capture the Spotify URI and use a spotify_entity timeline item whenever possible. Prefer the full spotify:... URI form, not a bare ID or open.spotify.com URL. Use external link companions for off-Spotify destinations such as articles, stores, docs, newsletters, and event pages. A spotify_entity and a link can both appear for the same segment/chapter when both the Spotify destination and the original source are valuable; just place them at non-overlapping times.

Segment-to-source integrity

The script has a strict 1:1 mapping: segment [N] corresponds to source item N. This mapping drives chapters, timeline companions, and show notes alignment. Never reorder, merge, or skip segments after assignment.

Save incrementally

Write collected data to disk after each sourcing step. If a later step fails, previous work is preserved.

Pacing and silence

Don't fear strategic silence. Pauses between segments give the listener time to absorb. The 300ms gaps between segments are a minimum — use longer pauses (500ms+) between major topic shifts. Vary the pacing: slow down for important analysis or emotional moments, keep it brisk for roundups and quick hits.

User Interview (MANDATORY)

Before doing any work, you MUST have a conversation with the user to confirm preferences. Do not assume defaults. Ask, then STOP and wait for their reply. Do not proceed until they respond. Skipping the interview will feel efficient; don't. Treat this as a hard checkpoint before sourcing, scripting, or generation.

At minimum, always confirm these before producing anything:

Content scope — What sources, topics, or material to use
Language — What language the episode should be in (do not assume from the source language)
Length — How long the episode should be
TTS voice — Which voice to use (offer options from references/audio-providers.md)
Cover image style — How to generate the cover image. Present these options (see references/cover-image.md for full details):
- User-provided — the user supplies their own image file
- AI-generated (default when image tools available) — unique image themed to the episode content, text composited with Pillow
- CDN artwork (terminal fallback) — pre-designed abstract illustration from the STS CDN with Pillow typography. Always available
Timeline companion images — How to produce images that appear in the player during playback. Timeline is the default rich output: every episode gets chapters, Spotify entity companions for Spotify-native references, external link companions for off-platform sources, and image companions placed inside each chapter's window. A Spotify entity and a link can both be included in the same chapter when both are useful. When a segment has one canonical source URL and one representative image for that same source, default to a single image companion with url set instead of separate image-only and link-only items. For images, present these options:
- AI-generated — DALL-E, Stable Diffusion, or the user's preferred image model, from a themed prompt per segment. Best when sources lack usable imagery (meditation, fiction, study, abstract topics) or when the user wants a consistent visual style
- Mixed (recommended default) — sourced where a natural image is available, AI-generated fill for segments that lack one. Aim for at least one image per chapter
- Skip — chapters and link companions only, no images. Lightest pipeline, still richer than the old chapters-only output
Show — After listing shows, ask whether to add this episode to an existing show or create a new one. Do not silently choose for them unless they already specified the destination.

Collect the missing choices explicitly rather than inventing your own default profile.

Ask these questions in your first response and STOP. Wait for the user to answer. Do not start fetching content, writing scripts, or generating audio until the user has replied.

If the user's initial prompt already covers some of these (e.g., "make an 8-minute English podcast about..."), skip those questions but still present a plan and wait for confirmation.

Plan confirmation

Before starting production, present a short plan:

Episode title, language, estimated length, number of segments, voice, show name

Say: "Here's what I'll produce — let me know if you'd like to change anything, or say 'go' to proceed."

Do not start production until the user confirms.

Execution Checklist

Every episode — regardless of content type — must complete these steps.

Preflight install and auth — Run save-to-spotify --json auth status before any sourcing. If the binary is missing, ask the user to confirm installation, install it with the command in the Install section after they approve, then run auth status again. If unauthenticated or token refresh is broken, prompt the user to save-to-spotify auth login first.
Interview — Ask the user about preferences, including companion-image source. Present a plan and wait for confirmation
Script — Write the script following this skill's universal rules (see references/content-quality.md)
Critique — Self-review the script, revise without reordering or removing segments
Produce — Generate audio per-segment, concatenate, convert to MP3 (see references/audio-providers.md). Build timeline.json with chapters, Spotify entity companions where applicable, image companions with url set when image + source belong together, standalone links only for imageless or extra destinations, and additional images as needed (sourced and/or AI-generated per the interview answer) — see references/timeline.md
Describe — Build the timestamped HTML description from the chapter entries in timeline.json and source URLs (see references/episode-description.md)
Cover image — Generate or select cover image (square, max 1 MB). MANDATORY — never skip this step (see references/cover-image.md)
Save — Save MP3 with title, description, and cover image via save-to-spotify --json upload (see references/cli-usage.md)
Timeline — Push timeline.json with timeline set (uploads image files automatically)
Verify — Poll episodes status until READY

Files

ATTRIBUTION.mdAdded by AutoGineer836 B
LICENSELicence file added by AutoGineer10.5 KiB
SKILL.md10.5 KiB
references/audio-providers.md13.7 KiB
references/cli-usage.md13.0 KiB
references/content-quality.md9.4 KiB
references/cover-image.md8.0 KiB
references/episode-description.md2.7 KiB
references/spotify-api.md7.7 KiB
references/timeline.md10.2 KiB

references/audio-providers.md

Audio Providers & Assembly

Reference for generating speech and assembling audio files for saving via save-to-spotify. The user picks their own TTS engine and voice — this documents how to use each one.

Tell the user:

The skill produces audio content that may be distributed via a streaming platform. Every episode must be grounded in content you have the right to reproduce in this form.

Production pipeline

Every episode walks the same steps. Recipes define what to write (sourcing, scripting, segment map). This reference covers generation and assembly.

Generate TTS audio per segment (one file each for exact chapter timing)
Generate silence files for transitions (300ms minimum between segments, 500ms+ between major shifts)
Concatenate all segments into a single MP3
Normalize volume levels
Calculate chapter timestamps from cumulative segment durations
Build timeline.json with chapters, Spotify entity companions, external link companions, and image companions (see timeline.md)

Accepted formats: .mp3, .m4a, .wav, .ogg (max 1 GB). Default to .mp3. Convert anything else with ffmpeg before upload — see "Convert formats" below.

Voice selection guide

Kokoro (local, free): af_alloy (American female, recommended), am_adam (American male), bf_emma (British female), bm_george (British male)
ElevenLabs (high quality, paid): Amelia, George, Bella
Edge TTS (free, 300+ voices): en-US-AriaNeural (F), en-US-GuyNeural (M)
OpenAI TTS (high quality, paid): nova, alloy, echo, onyx

Multi-voice / bilingual segments

Default to one voice per episode, but when the content is bilingual, role-played, or otherwise needs multiple voices, use a part-based segment schema and a flattened render manifest.

Example source schema:

{
  "segments": [
    {
      "title": "Swedish intro",
      "parts": [
        {"lang": "sv", "voice": "sv-SE-SofieNeural", "text": "Hej och valkommen."},
        {"lang": "en", "voice": "en-GB-LibbyNeural", "text": "Welcome back to the show."}
      ]
    }
  ]
}

Flatten that into a render manifest before synthesis:

[
  {"segment_index": 0, "part_index": 0, "lang": "sv", "voice": "sv-SE-SofieNeural", "text": "Hej och valkommen.", "out": "seg_00_00.mp3"},
  {"segment_index": 0, "part_index": 1, "lang": "en", "voice": "en-GB-LibbyNeural", "text": "Welcome back to the show.", "out": "seg_00_01.mp3"}
]

Concatenate manifest outputs in order, then compute chapter timestamps from the flattened audio segments.

Provider selection

When a content creation recipe is triggered and no TTS provider has been established, ask the user:

What TTS (text-to-speech) tool would you like me to use?
macOS say -- built-in, no setup, limited voices
Edge TTS (edge-tts) -- free, 300+ voices, 70+ languages
OpenAI TTS -- high quality, paid
ElevenLabs -- most natural, paid
Google Cloud TTS -- high quality, paid
Piper -- offline, fast, open-source
gTTS -- free, Google Translate quality
Amazon Polly -- cloud, paid
Something else?
Which voice do you prefer? (I can list available voices.)

Verification

Before generating, verify the chosen provider is available:

which say          # macOS (always available)
which edge-tts     # pip install edge-tts
which piper        # separate install
python3 -c "import openai"      # OpenAI
python3 -c "import elevenlabs"  # ElevenLabs

# ffmpeg is required for assembly
which ffmpeg && which ffprobe

If not installed, offer to install or suggest an alternative.

TTS provider reference

macOS `say`

say --voice '?'                                          # List voices
say -v <Voice> -o output.m4a --data-format=aac "Text"    # Generate m4a
say -v <Voice> -o output.m4a --data-format=aac -f in.txt # From file

Voices: Samantha (en-US), Daniel (en-GB), Alex (en-US high quality). Limited languages.

Edge TTS (recommended free option)

edge-tts --list-voices                                                  # List all
edge-tts --voice "en-US-AriaNeural" --text "Hello" --write-media o.mp3  # Generate
edge-tts --voice "en-US-GuyNeural" -f input.txt --write-media o.mp3     # From file
edge-tts --voice "en-US-AriaNeural" --rate="+10%" --text "Fast" --write-media o.mp3  # Faster
edge-tts --voice "en-US-AriaNeural" --rate="-30%" --text "Slow" --write-media o.mp3  # Slower

Key voices: en-US-AriaNeural (F), en-US-GuyNeural (M), en-GB-SoniaNeural (F), en-GB-RyanNeural (M), es-ES-ElviraNeural, fr-FR-DeniseNeural, de-DE-KatjaNeural, ja-JP-NanamiNeural, zh-CN-XiaoxiaoNeural.

OpenAI TTS

from openai import OpenAI
client = OpenAI()
resp = client.audio.speech.create(model="tts-1", voice="nova", input="Text")
resp.stream_to_file("output.mp3")

Voices: alloy, echo, fable, onyx, nova, shimmer. Use tts-1-hd for higher quality.

ElevenLabs

from elevenlabs import generate, save
audio = generate(text="Text", voice="Rachel", model="eleven_multilingual_v2")
save(audio, "output.mp3")

Most natural. Supports multiple languages.

Piper (offline)

echo "Text" | piper --model en_US-lessac-medium.onnx --output_file output.wav
ffmpeg -i output.wav -codec:a libmp3lame -qscale:a 2 output.mp3  # convert

Kokoro (local, free, no API limits)

from kokoro_onnx import Kokoro
import soundfile as sf
import numpy as np
import json

kokoro = Kokoro('kokoro-v1.0.onnx', 'voices-v1.0.bin')

segments = [
    ("Introduction", intro_text),
    ("Main Topic", body_text),
    ("Sign-off", outro_text),
]

timeline_items = []
all_samples = []
cursor_ms = 0

for title, text in segments:
    samples, sr = kokoro.create(text, voice='af_alloy', speed=1.0)
    timeline_items.append({"chapter": {"title": title, "start_time_ms": cursor_ms}})
    all_samples.append(samples)
    # 300ms silence between segments
    silence = np.zeros(int(sr * 0.3))
    all_samples.append(silence)
    cursor_ms += int((len(samples) + len(silence)) / sr * 1000)

combined = np.concatenate(all_samples)
sf.write('episode.wav', combined, sr)

with open('timeline.json', 'w') as f:
    json.dump({"items": timeline_items}, f, indent=2)

Convert to MP3: ffmpeg -i episode.wav -codec:a libmp3lame -b:a 192k episode.mp3

Voices: af_alloy (American female, recommended), am_adam (American male), bf_emma (British female), bm_george (British male). Fully offline, no API limits. Generates audio + chapter timestamps in one pass.

gTTS (free, basic)

gtts-cli "Text to speak" --lang en --output output.mp3
gtts-cli -f input.txt --lang en --output output.mp3

Google Cloud TTS

from google.cloud import texttospeech
client = texttospeech.TextToSpeechClient()
input_text = texttospeech.SynthesisInput(text="Text")
voice = texttospeech.VoiceSelectionParams(language_code="en-US", name="en-US-Neural2-F")
config = texttospeech.AudioConfig(audio_encoding=texttospeech.AudioEncoding.MP3)
resp = client.synthesize_speech(input=input_text, voice=voice, audio_config=config)
with open("output.mp3", "wb") as f:
    f.write(resp.audio_content)

Text sanitization for TTS

Before sending text to any TTS engine, clean it:

Strip markdown: **bold** -> bold, # heading -> heading
Remove hashtags, emojis, and non-speech artifacts
Expand abbreviations that sound wrong when spoken aloud
Replace em dashes — with hyphens - to avoid encoding issues in shell commands
Remove URLs from the spoken text (mention them as "link in the description" instead)

Audio assembly with ffmpeg

All content recipes generate multiple segments that must be joined into a single file; the segment boundaries become chapters in the timeline.

Generate silence

# 1.5 seconds (transitions between sections)
ffmpeg -f lavfi -i anullsrc=r=44100:cl=mono -t 1.5 -q:a 9 -acodec libmp3lame /tmp/silence_1.5s.mp3

# 3 seconds (recall pauses for language drills)
ffmpeg -f lavfi -i anullsrc=r=44100:cl=mono -t 3 -q:a 9 -acodec libmp3lame /tmp/silence_3s.mp3

# 5 seconds (speaking practice pauses)
ffmpeg -f lavfi -i anullsrc=r=44100:cl=mono -t 5 -q:a 9 -acodec libmp3lame /tmp/silence_5s.mp3

Concatenate segments

# Build a file list (order matters)
cat > /tmp/segments.txt << 'EOF'
file 'segment_01.mp3'
file 'silence_1.5s.mp3'
file 'segment_02.mp3'
file 'silence_1.5s.mp3'
file 'segment_03.mp3'
EOF

# Concatenate — re-encode rather than `-c copy`. Stream-copying small MP3
# segments yields non-monotonic frame timestamps that `loudnorm` silently
# drops audio on. The explicit `-ar 44100 -ac 1` also normalizes any stray
# stereo/48kHz segment to the common format so concat doesn't break.
ffmpeg -f concat -safe 0 -i /tmp/segments.txt -ar 44100 -ac 1 -c:a libmp3lame -b:a 192k /tmp/output.mp3

Normalize volume

Always normalize after concatenation — different TTS segments may have different levels:

ffmpeg -i /tmp/output.mp3 -af loudnorm /tmp/output_normalized.mp3

Convert formats

If the TTS outputs a format other than .mp3, .m4a, .wav, or .ogg, convert before upload:

ffmpeg -i input.aiff -codec:a libmp3lame -qscale:a 2 output.mp3
ffmpeg -i input.webm -codec:a libmp3lame -qscale:a 2 output.mp3

Get segment duration (for timeline timestamps)

ffprobe -v error -show_entries format=duration -of csv=p=0 segment.mp3

Timeline timestamp calculation

After generating all segments, build timeline.json by walking the file list, summing durations for chapter start times, and placing image/link companions inside each chapter's window. The only backend rule for companions is that they do not overlap with each other — chapter windows are independent.

import json, subprocess
from pathlib import Path

def ms(path):
    out = subprocess.check_output(
        ['ffprobe', '-v', 'error', '-show_entries', 'format=duration',
         '-of', 'csv=p=0', str(path)], text=True).strip()
    return int(float(out) * 1000)

# Each segment: (chapter_title, audio_file, companions)
# companions is a list of dicts:
#   {"image": "img_01_a.jpg", "url": "...", "title": "..."}  -- image companion
#   {"link":  "https://..."}                                  -- external link
#   {"spotify_entity": "spotify:track:4uLU6hMCjMI75M1A2tKUQC"}  -- Spotify card
#
# When a spotify_entity is used for a track/album/artist, do NOT also add an
# image companion with that entity's artwork — the card already renders it.
segments = [
    ("Introduction",   "segment_01.mp3", []),
    ("Chapter A",      "segment_02.mp3", [
        {"spotify_entity": "spotify:track:4uLU6hMCjMI75M1A2tKUQC"},
        {"link":  "https://example.com/article-1"},
    ]),
    ("Chapter B",      "segment_03.mp3", [
        {"image": "img_03_a.jpg", "url": "https://example.com/article-2", "title": "Source photo"},
    ]),
    ("Sign-off",       "segment_04.mp3", []),
]
silence_ms = ms('silence_1.5s.mp3')

items = []
cursor = 0
for title, audio, companions in segments:
    items.append({"chapter": {"title": title, "start_time_ms": cursor}})
    dur = ms(audio)
    # Distribute companions evenly inside the chapter window, with a 500 ms buffer.
    if companions:
        usable = dur - 500 * (len(companions) + 1)
        slot = max(usable // len(companions), 1000)
        for i, c in enumerate(companions):
            start = cursor + 500 + i * (slot + 500)
            duration = slot
            if "spotify_entity" in c:
                items.append({"spotify_entity": {"start_time_ms": start, "duration_ms": duration, "uri": c["spotify_entity"]}})
            elif "image" in c:
                item = {"image": {"start_time_ms": start, "duration_ms": duration, "image": c["image"]}}
                if c.get("url"):   item["image"]["url"] = c["url"]
                if c.get("title"): item["image"]["title"] = c["title"]
                items.append(item)
            elif "link" in c:
                items.append({"link": {"start_time_ms": start, "duration_ms": duration, "url": c["link"]}})
    cursor += dur + silence_ms

# Every chapter's start_time_ms must be strictly less than the assembled
# audio duration; nothing downstream can verify this.
final_ms = ms('episode.mp3')
last_chapter_ms = max(it["chapter"]["start_time_ms"] for it in items if "chapter" in it)
assert last_chapter_ms < final_ms, (
    f"last chapter at {last_chapter_ms} ms >= episode duration {final_ms} ms"
)

Path('timeline.json').write_text(json.dumps({"items": items}, indent=2))

The agent passes timeline.json to save-to-spotify --json timeline set --episode-id <EP_ID> --from-file timeline.json. The CLI uploads each local image file to Spotify's image store and swaps the path for the returned upload token before PUT-ing the timeline.

Standard workflow (used by all recipes)

1. User provides: topic + sources + voice preferences + companion-image source (sourced / AI-generated / mixed / skip)
2. Agent writes: structured script broken into segments, with source URL(s) and image hint per segment
3. Agent generates: one audio file per segment via TTS provider
4. Agent generates: silence files for pauses/transitions
5. Agent assembles: concatenate segments into single .mp3
6. Agent normalizes: volume levels
7. Agent gathers companion images: download from source and/or generate with DALL-E/SD
8. Agent calculates: chapter timestamps from segment durations
9. Agent builds: timeline.json with chapters + spotify_entity companions + link companions (source URLs) + image companions
10. Agent saves: save-to-spotify --json upload ...
11. Agent sets timeline: save-to-spotify --json timeline set ...
12. Agent polls: episodes status until READY

Recipes define steps 1-2 (what to write, which URLs and images to gather). This reference covers steps 3-9. The main SKILL.md covers steps 10-12.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs network access

Security

What our scanner noticed· Medium risk

Instructions that use the network
Downloads piped into a shell

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by

Cline

Publisher

Cline (Official)

Source

cline/skills · skills/save-to-spotify · commit 2637846

Licence

Apache License 2.0 (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-09

AutoGineer is not affiliated with or endorsed by Cline or Cline.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download save-to-spotify.zip

From the author

AutoGineer summary

What it does

When to use it

Advantages

Usage examples

Install

Documentation by Cline

Audio Content Production Skill

Reference Directory

Install

Core Principles

Read-only. Always.

Be the listener's eyes

Deep-link everything

Respect Third-Party Rights

Prefer Spotify-native references

Segment-to-source integrity

Save incrementally

Pacing and silence

User Interview (MANDATORY)

Plan confirmation

Execution Checklist

Files

references/audio-providers.md

Audio Providers & Assembly

Production pipeline

Voice selection guide

Multi-voice / bilingual segments

Provider selection

Verification

TTS provider reference

macOS say

Edge TTS (recommended free option)

OpenAI TTS

ElevenLabs

Piper (offline)

Kokoro (local, free, no API limits)

gTTS (free, basic)

Google Cloud TTS

Text sanitization for TTS

Audio assembly with ffmpeg

Generate silence

Concatenate segments

Normalize volume

Convert formats

Get segment duration (for timeline timestamps)

Timeline timestamp calculation

Standard workflow (used by all recipes)

Requirements and compatibility

Security

Attribution and licence

Related skills

Wizard

Emails

Conversion Tracking

Directory Submissions

Sms

Marketing Loops

Download ZIP

macOS `say`