Demo Precacher

Pre-generate and cache all demo content before live presentations — hit every API endpoint in advance, verify playback, report coverage gaps. Use before hack...

Security Scan

The skill's purpose (pre-generating demo content) matches what the code does, but there are a few inconsistencies and missing declarations (undeclared GEMINI key, undeclared dependencies, and placeholder Turso URL) that you should review before running it with real credentials.

Purpose & Capability

Name/description align with the behavior: the script generates stories (Mistral), TTS/SFX (ElevenLabs), and stores cached assets in a Turso DB. The required env vars (ELEVENLABS_API_KEY, MISTRAL_API_KEY, TURSO_AUTH_TOKEN) are reasonable for that purpose.

Instruction Scope

SKILL.md and script instruct the agent to call external APIs (Mistral, ElevenLabs, optionally Gemini) and to write generated content to Turso. The instructions do not read unrelated local files or attempt to modify other skills. However, the included Python script references GEMINI_API_KEY for image generation even though that key is not declared in the skill metadata.

Install Mechanism

No install spec (instruction-only) — lower install risk. The shipped script imports httpx, mistralai, and google.generativeai; these dependencies and a Python runtime are not declared. That means the environment running this script must already have these libraries, or the operator must install them — a missing declaration to be aware of.

Credentials

The declared environment variables (ELEVENLABS_API_KEY, MISTRAL_API_KEY, TURSO_AUTH_TOKEN) are proportional to the stated functionality. However, the script optionally reads GEMINI_API_KEY (via os.environ.get) but GEMINI_API_KEY is not listed as a required env var in the skill metadata. Also, TURSO_AUTH_TOKEN grants write access to a database; ensure you provide a token with minimum required scope and that storing base64-encoded audio/images in your Turso DB is acceptable.

Persistence & Privilege

always is false and the skill does not request persistent platform privileges. It performs network calls and writes to a user-provided Turso DB only, which is consistent with its stated job.

What to consider before installing

This skill generally does what it says: call your LLM/TTS/SFX/image APIs, encode outputs, and save them in Turso. Before installing or running it: (1) Verify and be comfortable with the three declared secrets; provide a Turso token with least privilege and verify the target TURSO_URL is correct (the script currently uses a placeholder). (2) Note that the script optionally uses GEMINI_API_KEY for image generation but that key is not declared — if you don't want image generation enabled, leave GEMINI_API_KEY unset so the script will skip it. (3) The script requires Python and third-party packages (httpx, mistralai, google.generativeai) — run it in an isolated environment (sandbox or container) and install only the needed deps. (4) Review the code yourself (or run in a safe test account) to ensure no unexpected endpoints or behaviors are present before supplying real credentials.

The golden rule of AI demos: never rely on live API calls during a presentation. This skill provides a systematic approach to pre-generating and verifying all demo content before you go live.

Why This Exists

In a 48-hour hackathon, we had 18 stories across 10 languages with audio narration, sound effects, and background music. During the demo, the Mistral API had a 3-second latency spike. Because everything was pre-cached, the demo played flawlessly from cache while the audience assumed it was generating in real-time.

The Pattern

async def precache_demo():
    scenarios = [
        {"name": "Sophie", "language": "fr", "prompt": "A story about cloud whales..."},
        {"name": "Kai", "language": "ja", "prompt": "A story about bamboo forests..."},
    ]
    
    for s in scenarios:
        # Step 1: Generate content (hits the real API)
        story = await generate_story(s["prompt"], s["name"], s["language"])
        
        # Step 2: Cache the result
        await cache.set(s, story)
        
        # Step 3: Generate all derived content (audio, images)
        for scene in story["scenes"]:
            audio = await generate_tts(scene["text"], voice_id)
            await cache.set(f"audio_{scene['id']}", audio)
        
        # Step 4: Verify playback
        cached = await cache.get(s)
        assert cached is not None, f"Cache miss for {s['name']}"
    
    # Step 5: Report coverage
    print(f"Cached {len(scenarios)} scenarios, all verified ✅")

Checklist

Before any live demo, verify:

• All primary scenarios cached and verified
• Audio files playable (correct format, no corruption)
• Fallback content available if cache miss occurs
• Demo account credentials working
• Network not required for cached playback
• Cache TTL won't expire during the presentation

Files

• scripts/precache_demo.py — Example precacher with verification and coverage reporting