AutoGineer
Generated banner for Save To Spotify
Generated logo for Save To Spotify

Save To Spotify

ClineOfficialPublished by Cline

  • Skill
  • Workflow
  • Automation and integrations
  • Apache-2.0
  • Medium risk
Download ZIP

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

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/cline/save-to-spotify/download

  2. 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:

  1. Content scope — What sources, topics, or material to use

  2. Language — What language the episode should be in (do not assume from the source language)

  3. Length — How long the episode should be

  4. TTS voice — Which voice to use (offer options from references/audio-providers.md)

  5. 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

  6. 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

  7. 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.

  1. 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.

  2. Interview — Ask the user about preferences, including companion-image source. Present a plan and wait for confirmation

  3. Script — Write the script following this skill's universal rules (see references/content-quality.md)

  4. Critique — Self-review the script, revise without reordering or removing segments

  5. 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

  6. Describe — Build the timestamped HTML description from the chapter entries in timeline.json and source URLs (see references/episode-description.md)

  7. Cover image — Generate or select cover image (square, max 1 MB). MANDATORY — never skip this step (see references/cover-image.md)

  8. Save — Save MP3 with title, description, and cover image via save-to-spotify --json upload (see references/cli-usage.md)

  9. Timeline — Push timeline.json with timeline set (uploads image files automatically)

  10. Verify — Poll episodes status until READY

Files

references/spotify-api.md

Spotify Web API (catalog lookups)

Use this reference when a segment names something that already exists on Spotify and the timeline should include a spotify_entity companion. This file covers the save-to-spotify-specific wiring: how to get a bearer token from the CLI, how to resolve names to spotify:... URIs, and when to omit a low-confidence entity.

Treat Spotify for Developers as the source of truth for endpoint shapes, parameters, schemas, and policy. Use the Spotify Web API rather than third-party catalogs, because timeline entries need Spotify URIs rather than cross-platform tap-throughs.

Start with Spotify for Developers

Before scripting Web API calls, load the official developer context:

  • https://developer.spotify.com/llms.txt - LLM-ready entrypoint for Spotify's developer platform.

  • https://developer.spotify.com/documentation/web-api/tutorials/building-with-ai - Web API guidance for AI coding assistants and agents.

  • https://developer.spotify.com/reference/web-api/open-api-schema.yaml - full OpenAPI 3.0 schema for the Spotify Web API.

The OpenAPI schema declares the base server (https://api.spotify.com/v1), paths, parameters, response schemas, and OAuth requirements. If the official docs or schema disagree with this local reference, follow developer.spotify.com.

Quick spec workflow:

SPEC_URL="https://developer.spotify.com/reference/web-api/open-api-schema.yaml"
curl -fsSL "$SPEC_URL" -o spotify-openapi.yaml
rg -n "^  /search:|operationId: search|get-an-album|get-an-artists-albums" spotify-openapi.yaml

Getting a bearer token

save-to-spotify token prints the current access token to stdout. That token has been verified to work as a Spotify Web API Bearer token for requests against api.spotify.com, so agents do not need a separate app registration for the catalog lookups below.

Guard the call because it exits non-zero when the stored token cannot be refreshed:

if ! TOKEN=$(save-to-spotify token); then
  echo "not authenticated; run: save-to-spotify auth login" >&2
  exit 1
fi

For a quick auth smoke test against the catalog API:

curl -sfG "https://api.spotify.com/v1/search" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "q=artist:The Beatles" \
  --data-urlencode "type=artist" \
  --data-urlencode "limit=1" >/dev/null

No extra scope grant is needed for public catalog search and metadata lookups. Check the OpenAPI security entries before using user-private data or mutating endpoints.

Resolving names to Spotify URIs

Pattern: GET /v1/search?q=<query>&type=<entity>&limit=5, then pick the best match from .<entity>s.items.

For albums and tracks, use field-qualified queries (artist:X album:Y or artist:X track:Y) for higher precision than free text:

TOKEN=$(save-to-spotify token) || exit 1
curl -sG "https://api.spotify.com/v1/search" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "q=artist:The Beatles album:Abbey Road" \
  --data-urlencode "type=album" \
  --data-urlencode "limit=5" \
| jq '.albums.items[] | {uri, name, release_date, artists: [.artists[].name]}'

Minimal dependency-free Python wrapper:

import json
import subprocess
from urllib.parse import urlencode
from urllib.request import Request, urlopen

API = "https://api.spotify.com/v1"

def spotify_token():
    return subprocess.run(
        ["save-to-spotify", "token"],
        capture_output=True,
        text=True,
        check=True,
    ).stdout.strip()

def spotify_get(path, params):
    url = f"{API}{path}?{urlencode(params)}"
    req = Request(url, headers={"Authorization": f"Bearer {spotify_token()}"})
    with urlopen(req, timeout=20) as resp:
        return json.load(resp)

def spotify_search(query, entity_type, limit=5):
    data = spotify_get("/search", {"q": query, "type": entity_type, "limit": limit})
    return data.get(f"{entity_type}s", {}).get("items", [])

For ambiguous names (self-titled albums, common words, cover-versus-original tracks), score each result before accepting it. Weight artist-name overlap, title overlap, and entity-specific metadata like album_type, release_date, show.name, or track duration. Drop the spotify_entity companion rather than ship a wrong URI when no result scores confidently.

Entity query patterns

Albums and tracks support the field-qualified form above. Artists, playlists, shows, and episodes take free-text queries; feed the user-visible name and change the type= parameter:

EntityQuerytype=Response pathOutput URI
Albumartist:X album:Yalbum.albums.items[]spotify:album:...
Trackartist:X track:Ytrack.tracks.items[]spotify:track:...
ArtistX (name)artist.artists.items[]spotify:artist:...
PlaylistX (name)playlist.playlists.items[]spotify:playlist:...
ShowX (name)show.shows.items[]spotify:show:...
Episodeshow title episode titleepisode.episodes.items[]spotify:episode:...

Podcast episode results are noisier than track and album search; verify the top hit's show.name field before accepting.

Useful catalog endpoints

Use the OpenAPI schema before expanding this list, but these are the common calls for timeline entity resolution:

NeedEndpoint
Search any catalog typeGET /v1/search?q=...&type=album,track,artist,playlist,show,episode
Full album / track / artist metadataGET /v1/albums/{id}, GET /v1/tracks/{id}, or GET /v1/artists/{id}
Artist's recent albums, excluding singlesGET /v1/artists/{id}/albums?include_groups=album&limit=50
Playlist metadata and tracksGET /v1/playlists/{id}
Show / episode metadataGET /v1/shows/{id} or GET /v1/episodes/{id} with market=<ISO country>
Show's episode listGET /v1/shows/{id}/episodes?market=<ISO country>&limit=50
New Releases, editorial albums onlyGET /v1/browse/new-releases?country=US&limit=50

For endpoints with a market parameter, use an ISO 3166-1 alpha-2 country code when needed. With a valid user access token, the country associated with the user account takes priority over the query parameter; see the OpenAPI QueryMarket parameter before adding market-specific logic.

Fallbacks and non-Spotify data

When sourcing a Spotify-native reference, the fallback hierarchy is:

  1. Spotify Web API - primary. Always try it first when auth is valid.

  2. No entity - omit the spotify_entity companion rather than invent or guess a URI.

If Spotify auth fails, fix auth first with save-to-spotify auth login. Do not substitute for other third-party catalogs as the timeline destination just because auth failed. Those sources can help verify dates, credits, or artwork, but they do not produce the spotify:... URI the Now Playing View needs.

Rate limits

Spotify's Web API is rate-limited per token; a sensible guardrail is about 10 req/s with small jitter. On HTTP 429, honor the Retry-After header. A typical episode's 10-20 lookups are well under the limit.

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

AutoGineer is not affiliated with or endorsed by Cline.

Download ZIP

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