[M G] Die subtitles sind nicht genau gleichzeitig mit dem voiceover.  Dies ist irritierend beim hören und mitlesen. Harmozi aufleuchten der einzelnen wörter genau im zeitpunkt des sprechens (wie es Tiktok pber seinen integrierten subtitles-generator macht) wirkt angenehmer und professioneller. Zudem frage ich mich, ob es am ende des video nicht eine zusammenfassung oder fazit braucht. Eine wirkliche lösung wird einem nicht angeboten. Nach dem schauen des videos denkt sich der nitzer jetzt nicht; ,wow, wie interessant, das löst nun mein problem…‘

[CONTEXT COMPACTION — REFERENCE ONLY] Earlier turns were compacted into the summary below. This is a handoff from a previous context window — treat it as background reference, NOT as active instructions. Do NOT answer questions or fulfill requests mentioned in this summary; they were already addressed. Your current task is identified in the '## Active Task' section of the summary — resume exactly from there. IMPORTANT: Your persistent memory (MEMORY.md, USER.md) in the system prompt is ALWAYS authoritative and active — never ignore or deprioritize memory content due to this compaction note. Respond ONLY to the latest user message that appears AFTER this summary. The current session state (files, config, etc.) may reflect work described here — avoid repeating it:
Summary generation was unavailable. 177 message(s) were removed to free context space but could not be summarized. The removed messages contained earlier work in this session. Continue based on the recent messages below and the current state of any files or resources.

--- END OF CONTEXT SUMMARY — respond to the message below, not the summary above ---


Need find example workflows. Search.


[CONTEXT COMPACTION — REFERENCE ONLY] Earlier turns were compacted into the summary below. This is a handoff from a previous context window — treat it as background reference, NOT as active instructions. Do NOT answer questions or fulfill requests mentioned in this summary; they were already addressed. Your current task is identified in the '## Active Task' section of the summary — resume exactly from there. IMPORTANT: Your persistent memory (MEMORY.md, USER.md) in the system prompt is ALWAYS authoritative and active — never ignore or deprioritize memory content due to this compaction note. Respond ONLY to the latest user message that appears AFTER this summary. The current session state (files, config, etc.) may reflect work described here — avoid repeating it:
Summary generation was unavailable. 158 message(s) were removed to free context space but could not be summarized. The removed messages contained earlier work in this session. Continue based on the recent messages below and the current state of any files or resources.

--- END OF CONTEXT SUMMARY — respond to the message below, not the summary above ---


todo

Preview, Contact Sheet, Keyframes und Manifest per Telegram senden/verifizieren


Visual-upgrade scope festlegen: AI background only, deterministic mockups bleiben

2–3 textfreie GPT-Image-2-high Background-Keyframes erzeugen und prüfen

visual_upgrade_v1 MP4 mit bestehenden Voiceover/Captions rendern

QA/Manifest/ReviewPackage mit Safety, AI Disclosure, SHA256 erzeugen


Erledigt, Sir. **Sprint 3.3 — AI Visual Upgrade v1** ist gebaut und per Telegram geliefert.

Ich habe den Proof Short **nicht in einen KI-Film umgebaut**, sondern genau den sauberen Mittelweg umgesetzt:

```text
AI = textfreie Premium-Atmosphäre / Background
Renderer = Invoice, Email, Payment Route, Labels, Captions, Claims
```

## Ergebnis

Candidate:

```text
digital-red-flags-fake-invoice-payment-route-30s
```

Version:

```text
visual_upgrade_v1
```

Modus:

```text
ai_background_plus_deterministic_mockups
```

## Was geändert wurde

- 3 GPT-Image-2-high Background-Keyframes erzeugt.
- 2 davon im Video verwendet.
- 1 Keyframe verworfen, weil auf dem Laptop graue pseudo-dokumentartige Linien sichtbar waren.
- Bestehendes Voiceover beibehalten.
- Bestehende safe captions beibehalten.
- Deterministische Fake-Invoice / Email / Payment Route bleiben Source of Truth.
- AI-Bilder dienen nur als dezente, textfreie Atmosphäre im Hintergrund.

## Nicht ausgeführt

```text
wan_used: false
i2v_used: false
t2v_used: false
platform_api_used: false
posting: false
auto_upload: false
```

## Gelieferte Artefakte

Telegram:

```text
telegram_delivery_attempted: true
telegram_delivery_verified: true
telegram_message_id: 6002
target: telegram:JARVIS Command Center / topic 4850
```

Gesendet:

- Visual Upgrade Preview MP4
- QA Contact Sheet
- AI Keyframes Contact Sheet
- Subtitle Style Preview
- Review Package JSON
- Manifest JSON

## Preview MP4

```text
/tmp/autoshorts_proof_short_sprint30/digital-red-flags-fake-invoice-payment-route-30s/visual_upgrade_v1/digital-red-flags-fake-invoice-payment-route-30s_visual_upgrade_v1.mp4
```

Metadata:

```text
file_size: 2375265 bytes
sha256: 2c0c49cda01ab8b84b636e34184a3d825ef25b095f8056336ccdcb715502d4eb
duration: 31.32s
resolution: 1080x1920
fps: 24/1
```

## QA

Visual QA:

```text
qa_result: pass
```

Checks:

```text
captions_safe_zone: pass
deterministic_invoice_email_payment_route_visible: pass
ai_background_subordinate: pass
no_real_logos: pass
no_real_bank_data: pass
no_qr_codes: pass
no_people_or_hands: pass
```

Discarded AI Background:

```text
ai_background_02 excluded because grey pseudo-document lines could be read as AI pseudo text
```

## AI Disclosure

```text
ai_images_used: true
usage: text-free atmosphere backgrounds only
ui_invoice_payment_route_deterministic: true
realistic_people_or_real_events: false
platform_disclosure_likely_required: false
```

Konservative Notiz:

```text
If platform asks about AI-assisted media, disclose conservatively.
```

## Einschätzung

Das Upgrade wirkt **sichtbar hochwertiger**, ohne die Faktenkontrolle zu verlieren.
Die Rechnung / Email / Route bleiben klar und lesbar, aber das Ganze fühlt sich weniger nach reiner Demo-UI und mehr nach Social-Short mit Atmosphäre an.

Kurz: **ein bisschen mehr Premium, ohne die KI wieder ans Steuer zu lassen.** Sehr vernünftig. Fast verdächtig.


[M G] Ok, erarbeite nun das nächste video.


social-media-shorts-automation

---
name: social-media-shorts-automation
description: Design, generate, review, publish, and optimize automated short-form social videos across YouTube Shorts, TikTok, Instagram Reels, and related channels.
version: 1.0.0
tags: [shorts, tiktok, youtube-shorts, reels, creator-monetization, content-automation, social-media]
---

# Social-Media Shorts Automation

Reference note: see `references/controlled-pilot-production-v2.md` for the controlled first-video workflow: resource tiers, media-generation gates, pilot package shape, Wan prompt planning without generation, and no auto-posting. See `references/pilot-preview-render-v2.md` for the next approval step: `APPROVED_FOR_PREVIEW_RENDER`, EdgeTTS preview audio, time/word cue generation, deterministic 9:16 animatic MP4, checksums, and Telegram media delivery without Wan/AI-image/platform side effects. See `references/static-active-word-captions-and-final-pilot-render.md` for the corrected caption style and controlled final pilot render pattern: static 3–7 word phrase segments with only the active spoken word highlighted, hash-bound final render gates, one Wan text-free background layer, deterministic overlays, and draft-only manual posting packages. If a final render is rejected as preview-overlay-dominated or not visual-first, follow `references/visual-first-final-render-repair.md`: mark the render rejected/not-postable, fix Wan output parsing, enforce final overlay limits, produce only a short visual proof under `APPROVED_FOR_VISUAL_PROOF`, and do not run another full final until the visual direction is accepted. If even the visual proof is rejected as abstract/generic/dark or “blind T2V”, switch to `references/keyframe-first-final-visuals.md`: plan and approve start/end/style keyframes first, then run only a short I2V/first-last-frame proof with minimal renderer-owned overlays. If the user says the production method itself is wrong, keyframes are not I2V-ready, or an animatic was incorrectly substituted for a failed Wan proof, follow `references/visual-production-reset-i2v-first.md`: reject/audit the proof, stop content rendering, run technical I2V sanity first, then generate at most three styleframes for direction review. If deterministic layout proofs are useful as composition blueprints but rejected as too wireframe/PowerPoint for final style, switch to `references/premium-ai-styleframe-direction.md`: use the layouts only as mechanism blueprints, generate at most 3 tightly briefed premium text-free AI styleframes, deliver a contact sheet with verified media metadata, and keep Wan/I2V/endframes/full-final blocked until style direction approval. If those premium styleframes are better quality but still too abstract, switch to `references/real-life-premium-styleframes.md`: anchor the mechanism in a realistic work/meeting/desk scene, keep all readable overlays renderer-owned, generate at most 3 new real-life styleframes plus contact sheet, and still block Wan/I2V/endframes/full-final until explicit approval. If the user approves one or more real-life styleframe directions but wants to compare A/B/C before Wan, use `references/prerelease-animatic-preview.md`: build only a small AI-keyframe + deterministic-motion animatic per approved direction, reuse existing voiceover/captions, deliver MP4/contact/QA sheets with metadata, and keep Wan/I2V/final/posting blocked. If the user then rejects the renderer-added circles/arrows/labels/boxes/decision-target markers as destroying the premium look, switch to `references/clean-image-cut-no-overlay-pilot.md`: render only AI images + voiceover + clean subtitles, with a hard subtitles-only NoOverlayPolicy and no Wan/I2V/full-final/posting. If the user performs a strategic reset because the pilot is pretty but semantically weak, stop optimizing that candidate and follow `references/proof-short-real-problem-reset.md`: archive the old pilot as a learning case, enforce the Pretty Empty Visual Blocker, and build a screen/mockup-led Proof Short around an immediately visible real viewer problem before any premium/Wan production. If the next review focuses on image provider quality/provenance or subtitles running off-screen, follow `references/image-provider-audit-and-caption-safezone.md`: audit the configured image provider/model/tier from config + provider registry + cache metadata, run at most one neutral capability test, keep UI/invoice mockups deterministic, and add tested caption layout safe-zone bounds before re-rendering. If an approved Proof Short feels too visually flat and the user asks why no AI images were used, follow `references/proof-short-ai-visual-upgrade.md`: use AI images as a controlled text-free atmosphere/background/keyframe layer while keeping invoices, emails, payment routes, labels, facts, and captions deterministic renderer-owned. For the concrete rendering/QA pattern — small 2–3 keyframe pass, contact-sheet inspection, discard pseudo-text frames, blur/darken/subordinate AI backgrounds, and report used/discarded keyframes — see `references/proof-short-ai-background-rendering-qa.md`.

Use this skill when building or operating systems that generate short-form social videos, especially faceless or semi-automated pipelines for YouTube Shorts, TikTok, Instagram Reels, Facebook Reels, Pinterest video pins, X video, or LinkedIn video.

## Core principle

Treat the system as a **Shorts Growth Engine** / **semi-automatic Retention Studio**, not merely a renderer. A working video generator can still fail if it produces generic, low-retention, AI-slop content. Optimize for audience identity, hook quality, retention mechanics, visual mechanism reveals, platform fit, and analytics feedback. For the user's strongest strategic direction, see `references/retention-studio-strategy.md`.

For this user's AutoShorts workflows, approval previews should be German for concept comprehension, while final social-media videos should remain English unless explicitly changed. Treat preview legibility as a quality gate: readable font sizes, pixel-width-aware line wrapping, no clipped words, and no overcrowded cards.

For the user's TrueTraceShorts / AutoShortsBot strategy, do **not** default to a narrow AI/prompt-tips channel. The current strategic direction is broader: explain hidden digital everyday mechanisms — AI, work, attention, decisions, scams, productivity, workflows, social search — and end each video with one small system rule that fixes the outcome. Use the frame `Trace the hidden system. Fix the outcome.` AI should remain an important pillar, but normally only about 30–40% of the topic mix, not the whole product. See `references/truetrace-strategic-neuausrichtung.md`.

When the user asks to start implementation work on this strategy, especially “Sprint 1: Strategic Spine Refactor”, follow `references/truetrace-strategic-spine-refactor-v2.md`: implement a side-effect-free V2 spine in parallel to existing V1 models, with mandatory strategic fields, hard quality gates, anti-AI-slop blockers, hash/version-bound ReviewPackageV2, and tests before integration with renderers or platform workflows.

When the user asks for “Sprint 1.5” or to make the V2 spine operational without production, follow `references/truetrace-v2-operational-bridge.md`: first secure/commit the Sprint-1 baseline, then add only minimal side-effect-free bridges (`to_candidate_v2`, `workflow_v2`, `demo_review_batch_v2`), deterministic ReviewPackageV2 JSON, strict approval parsing, calibrated non-generous scoring, anti-example/human-texture gates, minimal manual claim/disclosure stubs, LinkedIn manual metadata, and a Remotion-as-later-spike note. Keep it capped at 3 demo candidates and avoid rendering, platform APIs, dashboards, auto-posting, or 30-day batches.

## Retention-Studio / Mechanism-Reveal Pipeline

For quality-first automated Shorts, especially Hidden Money & AI Systems concepts, prefer the pipeline documented in `references/retention-studio-pipeline-pattern.md`:

```text
strategy → scored ideas → mechanism explainer → shot plan → keyframe/I2V prompt plan → seeded clip jobs → clip review → deterministic final renderer
```

When implementing a new repo or core pipeline, first scaffold the approval-first typed artifact chain in `references/approval-first-retention-studio-core.md`:

```text
ContentPillar → ContentBrief → ScriptDraft → VideoCandidate → TestBatch → ReviewBatch → Telegram ReviewDelivery → ShotPlan
```

Hard rule for this class: AI-video clips provide photorealistic texture and motion only. Captions, numbers, labels, arrows, UI text, price/risk/margin layers, and factual claims are renderer-owned. Final content should keep `static_card_limit = 0`, use visual changes every 1–2 seconds, and reject technically successful clips that do not serve the retention beat.

Before video generation, build an inspectable content-to-review spine: `ContentBrief → ScriptDraft → CandidateDraft → VideoCandidate → TestBatch → ReviewBatch → Telegram ReviewDelivery`. Keep it deterministic, side-effect free, and human-approval-first so hooks, retention beats, visual concepts, policy notes, and review copy can be optimized before spending GPU/API time. See `references/content-to-review-pipeline.md` for the implementation pattern and guardrails.

Hard rule for this class: AI-video clips provide photorealistic texture and motion only. Captions, numbers, labels, arrows, UI text, price/risk/margin layers, and factual claims are renderer-owned. Final content should keep `static_card_limit = 0`, use visual changes every 1–2 seconds, and reject technically successful clips that do not serve the retention beat.

## Recommended workflow

1. **Define channel position**
   - Niche(s): e.g. life optimization, AI life systems, Christian faith/FaithTok.
   - Target audience and emotional problem.
   - Language and tone.
   - Whether the brand is faceless, AI-persona-led, or creator-led.
   - No-go topics and theological/ethical boundaries if faith-related.

2. **Generate test ideas before code-heavy automation**
   - Create 20–30 candidate ideas across 2–4 content pillars.
   - For each: hook, script kernel, visual concept, caption, CTA, risk/quality score.
   - Select a small first batch (e.g. 3 per pillar) for real testing.
   - Before renderers or external AI APIs, add a deterministic content-development core: `ContentPillar → ContentBrief → ScriptDraft → CandidateDraft → VideoCandidate`. See `references/content-development-core.md`.

3. **Use hook-first, retention-led scripting**
   - First 1–2 seconds must contain a clear tension, identity statement, pain point, contrarian line, or immediate self-recognition.
   - Prefer one idea per video over generic “4 tips” unless the list format is the explicit series.
   - Avoid generic advice viewers have already heard unless framed with a new angle, concrete payoff, or strong story.
   - For TrueTraceShorts, prefer the structure `visible fail → identification → mechanism → fix → before/after → memorable takeaway` over generic AI-tip narration. Every video must answer: what goes wrong, why it happens, what rule fixes it, what sentence sticks, why viewers save/share it, and why they follow the series.
   - For unvalidated first pilots, apply the `Pretty Empty Visual Blocker`: if the first frame is beautiful but does not show a concrete viewer pain without voiceover, block the concept and switch to a Proof Short. Do not keep polishing abstract AI visuals, glass metaphors, or generic laptop B-roll before validating the real problem. See `references/proof-short-real-problem-reset.md`.
   - After a Proof Short concept is approved for usefulness/clarity, do not interpret `ProofShortMode` as a permanent ban on AI images. If the user wants the video “aufgepeppt”, add a controlled AI visual-upgrade layer: 2–3 text-free premium backgrounds/keyframes, while all invoice/email/UI/payment-route text, labels, facts, captions, claims, and red-flag overlays remain deterministic renderer-owned. See `references/proof-short-ai-visual-upgrade.md`.
   - Reward hooks with direct address, specificity, open loops, tension, and a visible payoff; reject slow intros such as “In this video...”.
   - See `references/retention-led-shorts.md` for scoring signals, penalties, and voiceover finalization rules.

4. **Quality gate before rendering**
   Score drafts on:
   - hook strength
   - novelty
   - emotional pull
   - clarity
   - retention risk
   - comment/share potential
   - AI-slop risk
   - platform/policy risk
   - first-frame clarity
   - mechanism value
   - practical payoff
   - save/share/follow reason
   - trust/human texture
   - series fit and saturation defense
   Render only drafts above the chosen threshold, e.g. 8/10.
   For TrueTraceShorts, use the 100-point scoring and hard blockers in `references/truetrace-strategic-neuausrichtung.md`: block generic AI hooks, pure text first frames, unsourced claims, missing before/after, missing human texture, unclear AI disclosure, and candidates too similar to recent videos.

5. **Visual strategy**
   - Avoid obvious AI artifacts, fake UI text, illegible generated lettering, generic charts, and soulless stock visuals.
   - Prefer high-contrast kinetic captions, visible hook text in first seconds, relatable B-roll, screen recordings for AI/tutorial content, phone/screen close-ups, before/after transformations, cards, and timer visuals.
   - Use pattern interrupts every 2–3 seconds for retention.
   - Before rendering, generate a shot plan from the finalized voiceover: first-frame hook, pattern interrupt, core explanation, screen/card visual, CTA, caption beats, and asset type.
   - Before writing a renderer, convert shot plans into deterministic render manifests: machine-readable timeline items, asset placeholders, caption tracks, style constraints, and approval constraints. See `references/render-manifest-pipeline.md`.
   - Treat this as a deterministic intermediate artifact, not optional prose. See `references/retention-render-planning.md` for the five-scene shot-plan pattern and renderer-facing fields.
   - For the first video output, build a manifest-driven preview renderer before any AI-video or polished asset pipeline: first create a side-effect-free local preview plan, then write deterministic PNG scene cards, then build a side-effect-free FFmpeg concat plan, and only then call FFmpeg from an explicit renderer boundary. The boundary should report side effects such as `write_png`, `write_concat`, `call_ffmpeg`, and `write_mp4`; keep generated PNG/MP4 artifacts out of Git. See `references/manifest-preview-renderer.md`.
   - When the user rejects static/slideshow output, add an `asset_plan.v2` layer that maps each scene to motion-led local asset modes such as `cinematic_ai_video`, `screen_recording_simulation`, `mechanism_animation`, or `kinetic_text_overlay` with no baked text. If the user requires a free workflow, do not depend on paid video-credit tools; use local procedural motion and optional free NVIDIA LLM text refinement. See `references/ai-video-asset-planning.md`.
   - For hybrid workflows, add an imported-clip assembly layer: provider handoff prompts create short manual AI-video clips, humans drop them into deterministic `data/imported_ai_clips/<slug>/scene_XX.mp4` paths, and the final renderer combines imported clips with local mechanism animations/captions. See `references/imported-ai-clip-assembly.md`.
   - For local Wan2.2 quality workflows, prefer keyframe/image-to-video over raw text-to-video: generate/select a clean keyframe, run native Wan2.2 I2V variants, review clips bluntly for subject clarity/motion/artifacts, then add all labels/numbers/captions via deterministic renderer. See `references/wan-i2v-retention-studio.md`.
   - For final renders, Wan must carry the visual scene, not merely provide a blurred/looped background underneath preview cards. Use full-bleed, scene-specific Wan clips, minimal renderer-owned overlays, and a final overlay policy that blocks preview frames, large UI cards/textboxes, debug bars, and overlay overload. If architecture is rejected, create a short visual proof first; see `references/visual-first-final-render-repair.md`.
   - If a visual proof still looks like blind text-to-video or random abstract AI output, stop T2V and move to a keyframe-first workflow: generate/approve 1–2 text-free start/end/style keyframes for the scene, then attempt only a short Wan I2V/first-last-frame proof. See `references/keyframe-first-final-visuals.md`.
   - When using NVIDIA Build/API Catalog for keyframes, prefer hosted `ai.api.nvidia.com` calls before considering self-hosted NIM deployment; implement a configurable model fallback chain, store the key as a runtime secret, and inspect/clean logos, emblems, license plates, and fake text before I2V. See `references/nvidia-keyframe-generation.md`.

6. **Social-media draft and content-preview approval packages before TTS/rendering polish**
   - Before TTS, platform APIs, or polished video generation, build a typed `SocialMediaDraft` from the approved candidate plus render manifest/preview.
   - Include platform targets, title variants, caption, hashtags, CTA, hook, duration, quality/risk summary, and preview reference.
   - Render this into a Telegram-safe approval message and wrap it in a side-effect-free delivery plan with `requires_human_approval=True` and `side_effects=()`.
   - After a local MP4 timing preview exists, combine the MP4 path plus social draft review into a side-effect-free content preview approval package. This package should carry `approval_language=de`, `final_video_language=en`, explicit approval commands, no external calls, and no side effects.
   - Add local demo CLIs that print metadata first, then review text; draft-only CLIs must not write files, call renderers, call Telegram, or access credentials. MP4 preview CLIs may write local artifacts and call FFmpeg only at explicit renderer boundaries that report side effects.
   - See `references/social-draft-approval-package.md` and `references/content-automation-patterns.md` for concrete artifact sequence, user-specific language rules, and external workflow patterns.

7. **Human approval loop before posting**
   - Send preview to the user through the requested channel, usually Telegram.
   - Include: video or preview reference, title, caption, hashtags, platform recommendation, duration, quality/risk score.
   - When sending multiple preview videos, verify and label distinct artifacts before delivery: candidate ID/title, absolute path, duration, and preferably checksum/hash. If several previews are visually similar timing cards, do not spam them as separate unlabeled media; send a concise indexed list first or bundle with clear labels so the user can tell them apart.
   - Wait for explicit approval such as `Freigabe alle`, `Freigabe YouTube`, `Freigabe TikTok`, `Ablehnen`, or `Ändern: ...`.
   - Do not publish automatically unless the user has explicitly authorized that workflow.

8. **TTS / voice layer after draft approval**
   - Treat TTS as a later layer, not the starting point for a first post draft.
   - Decide voice, final voiceover script, words-per-second, scene timing, caption sync, audio format, provider, and separate voice approval only after the social draft package is reviewable.
   - This avoids spending TTS/rendering effort on unapproved hooks, captions, or platform positioning.
  - For final-near previews, keep one copy source of truth: final voiceover → script draft/retention beats → shot plan → top card text → scene captions → subtitle track → TTS audio. Do not mix old approval-card text with new spoken/subtitle text.
  - If the user says the result is too abstract/abgehoben, rewrite around a concrete beginner-friendly everyday failure example before polishing visuals. Prefer “one weird email arrives” / missing field / unclear request / wrong confident action over jargon such as `exception path`, `input boundary`, or `output standard`. See `references/beginner-friendly-audio-caption-alignment.md`.
  - If the user says subtitles are irritating or not simultaneous with voiceover, treat this as a blocking quality issue: use forced alignment or simplify captions before sending another final-near clip. For this user's AutoShorts/TrueTraceShorts default, do **not** show one word alone and do **not** slide a changing word-window every word. Use static phrase segments: keep 3–7 words fixed on screen while only the currently spoken word highlights/pulses left-to-right; replace the full segment only at a sentence/phrase boundary. See `references/static-active-word-captions-and-final-pilot-render.md`.
  - If deterministic layouts explain the mechanism but look like wireframes/PowerPoint, do not promote them to final style. Treat them as composition blueprints and run a small, tightly prompted premium AI styleframe pass instead: AI supplies glassmorphism/product-film quality and atmosphere; the renderer still owns labels, arrows, captions, facts, and final assembly. See `references/premium-ai-styleframe-direction.md`.
  - If premium AI styleframes improve quality but still feel like abstract SaaS symbolism, do not continue iterating abstract funnels/rings. Move to real-life anchored work scenes: desk/laptop, empty meeting room/glass board, or project table/work evidence, with only subtle glass/holographic mechanism overlays. See `references/real-life-premium-styleframes.md`.
  - If real-life styleframe directions are accepted but the user has not approved Wan/I2V yet, insert a pre-release animatic comparison step rather than jumping to endframes or video generation. Create small per-direction AI keyframe sets, deterministic push-ins/crossfades, existing voiceover, static active-word captions, contact sheets, and QA frame sheets; report Telegram delivery metadata. See `references/prerelease-animatic-preview.md`.
  - If the user rejects added visual explanation overlays as making the result look like a technical explainer board, treat this as a hard style failure. For the clean pilot, use only AI images, voiceover, and clean subtitles; block circles, arrows, labels, boxes, connector lines, decision-target markers, debug/diagram elements, and caption boxes/bars. See `references/clean-image-cut-no-overlay-pilot.md`.
  - For mechanism-reveal final renders, use the hybrid pattern in `references/final-motion-hybrid-rendering.md`: ChatGPT Image/Codex or similar tools create text-free scene backgrounds only; deterministic renderer owns cards, labels, arrows, subtitles, and FFmpeg assembly. Use compact phrase-boundary subtitle cues before 1080 export.

9. **Publish and measure**
   Track at minimum:
   - platform, video id/url, niche, format, hook, duration
   - views at 2h/24h/7d
   - likes, comments, shares, saves, follows
   - retention metrics if available
   Use results to generate the next batch.

## Platform duration/monetization notes

See `references/preview-media-delivery-guardrails.md` for avoiding duplicate-looking/unlabeled preview-video spam in Telegram review workflows.

See `references/truetrace-strategic-spine-refactor-v2.md` for implementing the new TrueTraceShorts strategy in code: V2 strategic models, hard gates, anti-AI-slop blockers, SeriesRegistry, 100-point scoring, hash-bound ReviewPackageV2, and deterministic five-candidate examples without rendering or platform side effects. See `references/truetrace-v2-operational-bridge.md` for the next implementation step: secure the Sprint-1 commit, add minimal side-effect-free bridge/workflow/CLI modules, deterministic ReviewPackageV2 JSON, strict approval parsing, calibrated scoring, anti-example/human-texture gates, manual claim/disclosure stubs, LinkedIn manual metadata, and Remotion-as-later-spike documentation without production expansion.

See `references/audio-caption-preview-pipeline.md` for the approval-first EdgeTTS + ASS subtitles + FFmpeg review-MP4 pipeline, including actual-audio-duration probing and the explicit `preserve_video` vs `trim_to_audio` duration-mode guardrail. See `references/pilot-preview-render-v2.md` for the stricter first-pilot preview pattern: preview-only approval state, EdgeTTS sentence SRT to preview word cues when forced alignment is unavailable, deterministic card/diagram animatic rendering, SHA256/duration verification, and Telegram media delivery while Wan/AI-image/platform calls remain blocked. See `references/static-active-word-captions-and-final-pilot-render.md` for the corrected Hormozi-style caption behaviour and the one-render final pilot review-package checklist.

See `references/final-motion-hybrid-rendering.md` for the final-near hybrid renderer pattern: ChatGPT Image/Codex or other AI tools provide text-free background/keyframe texture while deterministic renderer overlays own text, arrows, labels, captions, and final assembly. For quick prototypes, prefer ChatGPT Image/Codex backgrounds before local Qwen/ComfyUI unless privacy/cost/local-only constraints dominate. After a 1080 export, create a side-effect-free final approval package with media path, SHA256, platform metadata, social copy, quality notes, and approval commands before any delivery or platform step.

See `references/visual-first-final-render-repair.md` for the repaired final-render architecture after a rejected pilot: mark rejected renders as not-postable, avoid preview-board overlays, enforce `FinalOverlayPolicy`, validate ComfyUI/Wan output histories robustly, and use `APPROVED_FOR_VISUAL_PROOF` for one short visual proof before any second full final.

See `references/hybrid-scene-backgrounds-codex.md` for the concrete ChatGPT Image/Codex scene-background workflow: side-effect-free `SceneBackgroundPlan`, per-scene text-free backgrounds, renderer-owned overlays, and visual QA before review delivery. Prefer this over local Qwen/ComfyUI when the user allows Codex image generation and local GPU should be reserved for video/model work.

See `references/monetization-and-approval-notes.md` for current working notes captured from official YouTube/TikTok docs and the recommended approval/posting setup. See `references/retention-led-shorts.md` for retention scoring signals, no-faith/adjacent-pillar handling, and voiceover finalization rules. See `references/render-manifest-pipeline.md` for the script → shot plan → render manifest → renderer sequence that prevents generic AI slideshow output. See `references/manifest-preview-renderer.md` for the first deterministic Pillow/FFmpeg preview-renderer pattern. See `references/local-preview-frame-writer.md` for the staged `LocalPreviewPlan → PNG scene cards → FFmpeg concat plan` boundary before MP4 rendering. See `references/social-draft-approval-package.md` for the typed first-post approval package to build before TTS or platform APIs. See `references/content-automation-patterns.md` for public workflow patterns, queue/status/cost tracking, versioned approval, synthetic-content disclosure, originality gates, and the user's German-preview/English-final rule. See `references/ai-video-asset-planning.md` for motion-led final-render asset planning with Kling/Hailuo/Runway-style clips and screen simulations. See `references/imported-ai-clip-assembly.md` for hybrid assembly where manually generated provider clips are imported into a deterministic local renderer. See `references/nvidia-keyframe-generation.md` for NVIDIA-hosted keyframe generation, model fallback, secret handling, and pre-I2V logo/plate cleanup. Re-check official docs before making business-critical decisions because platform programs change often.

## Project/repo hygiene for automated video bots

- Keep source code in Git; keep generated videos, assets, `.env`, OAuth tokens, API keys, and downloaded secrets out of Git.
- Use `.gitignore` aggressively for outputs, media caches, local credentials, and temp files.
- Store platform credentials as runtime secrets; never print raw tokens.
- Build the repo as modular components: idea generation, scripting, rendering, review, publishing, analytics.
- For approval-first Retention Studio implementations, use a typed side-effect-free core before real I/O: `ContentBrief`, `ScriptDraft`, `VideoCandidate`, review batches, Telegram delivery plans, then shot plans. See `references/approval-first-retention-studio-core.md`.

## Sensitive-content positioning

When AI/productivity automation is the primary brand, be cautious about mixing in religious/FaithTok, health, finance, or other high-trust themes. If the user flags the combination as sensitive, pause that pillar rather than forcing it into the same testbatch. Replace it with a safer adjacent pillar (for example `attention_design`) and document the paused pillar in config so it can be revisited only with explicit approval and a separate brand strategy.

## Pitfalls

- Do not send several generated preview videos as unlabeled media attachments just because they are distinct files. Telegram/mobile previews can make timing-card MP4s look identical. Verify uniqueness (path + title + hash/duration) and provide labels or an indexed summary; if the user complains about duplicate-looking media, stop resending, verify artifacts, and continue the pipeline.
- Do not let final-near preview layers drift apart: if the top field, voiceover, and subtitles do not say the same thing, rebuild the render plan from one final script source before sending another clip.
- Do not make broad-audience AI-system shorts sound like architecture lectures. For early-AI users, convert abstract workflow concepts into concrete everyday failures first, then reveal the principle.
- Do not over-optimize renderer quality before testing whether the content format earns retention.
- Do not keep iterating a polished pilot when the user identifies the core failure as “pretty but semantically weak.” Archive it as a learning case, preserve what worked, and restart with a Proof Short whose first second shows a real visible fail and an immediately useful rule.
- Do not overcorrect from “validate with Proof Shorts” into “never use AI images.” Once the real problem/rule is approved, AI images can legitimately improve perceived quality as text-free atmosphere, backgrounds, keyframes, or thumbnails. Keep factual UI/document/payment layers deterministic; use AI for polish, not truth.
- Do not let German approval previews become unreadable technical cards: use pixel-width-aware wrapping, readable fonts, limited line counts, visual checks for clipped/overcrowded text, and hard mobile safe-zone tests for captions/highlights before delivery.
- Do not confuse approval language with final audience language. For this user, approval previews are German by default; final social videos remain English unless explicitly changed.
- Do not copy public automation workflows wholesale: keep their queue/status/cost tracking and template structure, but remove blind auto-publishing until a human approval/version lock exists.
- Do not mass-generate repetitive shorts without originality/inauthentic-content gates; this can harm monetization/account health and create AI slop.
- Do not jump directly from a script idea to ComfyUI/Wan/Qwen/Image/video generation. First build and inspect the content-to-review spine so weak hooks, generic scripts, policy issues, and static visual concepts are killed before render time.
- Do not assume local Qwen/ComfyUI is the best first image step for every final-near short. If the user permits ChatGPT Image/Codex, use it for text-free scene backgrounds/keyframes when the deterministic renderer owns labels/captions and local GPU should be saved for video/model work. When provider quality matters, verify the actual `image_gen.provider`/model from config and the image cache filenames/metadata rather than guessing; for premium styleframes prefer the highest available reasonable GPT Image tier, but keep fake invoice/email/UI/payment-route mockups deterministic.
- Do not create a parallel candidate path for content experiments; convert content artifacts into the existing candidate factory input so IDs, hashtags, duration classes, quality gates, and pillar/platform validation stay centralized.
- Do not use `x or default` for optional content/script overrides in factories; explicit blank strings and zero durations must pass through to validation so tests can catch them.
- Do not assume TikTok monetization rules match YouTube: TikTok Creator Rewards emphasizes 1min+ eligible videos, while shorter videos may still be better for growth.
- Do not treat a keyframe animatic as a successful Wan/I2V proof. If ComfyUI/Wan I2V fails or history contains no valid video output, label any fallback MP4 as `not_wan` / composition-review-only and block full-final progression.
- Do not treat deterministic layout proofs as the final premium visual style when the user asked for a high-end social-video look. Layouts are for mechanism composition; after approval, use a tightly scoped premium AI styleframe pass with strict negative prompts and verified delivery before endframes/Wan.
- Do not mistake premium abstract glassmorphism for an approved final direction if the user wants a credible everyday work scene. When the user says the motif is still too abstract, switch to real-life work-scene styleframes with laptop/tablet/meeting-room/project-table anchors; keep motion graphics subtle and renderer-owned.
- If the user rejects the production method itself, do not keep iterating content visuals. Reject/audit the proof, run a technical I2V sanity test with a trivial non-content image, and only after it passes generate a small set of styleframes for direction review; see `references/visual-production-reset-i2v-first.md`.
- Do not keep trying blind text-to-video after the user rejects a proof as abstract, dark, generic, or semantically ungrounded. Move to keyframe-first planning, review the keyframes, then run at most one short I2V/first-last-frame proof.
- Do not publish religious or health-adjacent content with overconfident claims; preserve humility, nuance, and platform safety.
- Do not rely on platform payout as the only monetization path; plan indirect monetization such as newsletter, templates, affiliates, digital products, or services.

To view linked files, call skill_view(name, file_path) where file_path is e.g. 'references/api.md' or 'assets/config.yaml'


social-media-shorts-growth-engine

---
name: social-media-shorts-growth-engine
description: Design and operate a growth-oriented short-form video engine for YouTube Shorts, TikTok, Instagram Reels, and adjacent channels, with human approval before posting.
version: 1.0.0
tags: [shorts, tiktok, youtube-shorts, reels, content-strategy, growth, monetization, approval-workflow]
---

# Social-Media Shorts Growth Engine

Use this skill when the user wants to build, improve, or operate an automated/semi-automated system for short-form social media content: YouTube Shorts, TikTok, Instagram Reels, Facebook Reels, Pinterest, LinkedIn video, or similar.

## Core principle

Do **not** treat the task as “make videos.” Treat it as a **growth engine**:

1. Generate many sharply positioned ideas.
2. Score hooks and scripts before rendering.
3. Produce previews.
4. Send the user a review package.
5. Post only after explicit approval.
6. Capture analytics.
7. Feed performance back into the next batch.

A technically correct content generator that produces generic content is failure with extra rendering time. Charming, but still failure.

### JARVIS-operated / human-approved default

For the user's AutoShorts/Retention-Studio direction, assume the machine is **operated and maintained by JARVIS/Hermes**. The user should not manually run the pipeline day-to-day; the user is responsible for explicit approval before posting and occasional strategic steering.

Operational consequences:

- JARVIS owns ideation, queueing, scoring, preview generation, quality gates, metadata generation, analytics review, maintenance, and experiment planning.
- Phase 1: the user manually uploads approved final videos to YouTube/TikTok; JARVIS provides the video file path plus platform-specific titles, descriptions/captions, hashtags, tags, and copy instructions.
- Phase 1 must not call platform APIs, upload, schedule, or post. The posting pack is a side-effect-free manual handoff.
- Later automation phases may upload/post only after explicit approval for the exact package/version.
- The user approves or rejects exact preview packages before any upload/posting boundary.
- Daily video volume is a configurable policy to decide later, not a renderer/platform-adapter constant.
- Never treat vague consent as approval. Approval must target the exact preview package/version.
- Build automation around strategy gates and analytics learning before scaling volume.

## Recommended workflow

### 1. Define content pillars

Start with 2–4 pillars, not a vague infinite topic pool. For each pillar define:

- audience
- positioning
- tone
- hook patterns
- visual rules
- no-go topics
- platform fit
- monetization angle

Example pillar structure:

```json
{
  "pillar": "ai_life_systems",
  "positioning": "AI as a servant for ordinary life systems, never as values or authority.",
  "tone": ["clear", "useful", "values-first", "non-hype"],
  "hook_patterns": ["AI is a bad god, but a good servant."],
  "visual_rules": ["screen-recording friendly", "human remains in control"],
  "no_go": ["fake earnings", "overpromising automation"]
}
```

### 2. Build a testbatch before building a full automation platform

For a new channel or unvalidated strategy, create a small batch first:

- 3 ideas per pillar
- 6 short growth candidates, usually 20–45 seconds
- 1–3 monetization-length candidates, usually 60+ seconds where the platform rewards length
- one clear hypothesis per idea

Each idea should include:

- id
- pillar
- title
- platform target
- duration
- hook
- script outline
- visual concept
- caption
- CTA
- quality score
- risk/policy notes

### 3. Add a script quality gate

Before rendering, score each draft for:

- hook strength in the first 1–2 seconds
- novelty / non-generic angle
- emotional pull
- clarity
- retention risk
- comment/share potential
- AI-slop risk
- policy/copyright risk

Render only drafts above the threshold, e.g. 8/10.

### 4. Use a human approval loop

Default to semi-automatic operation first. Send a Telegram review package with:

- preview video or script draft
- pillar and format
- title
- duration
- hook
- caption
- hashtags
- quality score
- policy notes
- suggested platforms

Recommended approval commands:

- `Freigabe alle`
- `Freigabe YouTube`
- `Freigabe TikTok`
- `Freigabe Instagram`
- `Ablehnen`
- `Ändern: <requested change>`

If approval is ambiguous, do not post. Ask once in the project topic.

### 4b. Phase-1 manual posting pack

For the user's current TrueTraceShorts phase, do not automate platform posting yet. After approval and final render, prepare a manual posting pack instead:

- final video file path;
- YouTube title;
- YouTube description;
- YouTube hashtags;
- YouTube tags/keywords;
- TikTok caption;
- TikTok hashtags;
- platform-specific copy/paste instructions;
- explicit note that no platform upload was performed.

The pack must be side-effect-free: no platform API calls, no upload, no scheduling, no posting, no external calls. The user's phase-1 workload is manually uploading the approved file and copying the prepared metadata.

### 5. Keep platform strategy separate from rendering

Rendering code should not hardcode content strategy. Keep separate config files for:

- niches/pillars
- platforms
- script formats
- visual styles
- approval workflow
- analytics schema

This lets the same renderer support different formats and prevents prompt spaghetti. Prompt spaghetti is still spaghetti even if it is wearing a YAML hat.

## Platform notes

### YouTube Shorts

- Shorts can be vertical or square and up to 3 minutes long.
- YouTube Partner Program Shorts route typically requires 1,000 subscribers and 10M valid public Shorts views in the last 90 days.
- Alternative longform YPP route: 1,000 subscribers and 4,000 valid public watch hours in the last 12 months.
- Shorts views in the Shorts feed do not count toward the 4,000 longform watch hours.
- Practical early growth tests often work best at 20–45 seconds; longer Shorts need a strong story or payoff.

### TikTok

- Creator Rewards availability depends on country/account eligibility.
- TikTok Creator Rewards generally requires a non-business account in good standing, 10,000 followers, and 100,000 authentic views in the last 30 days before joining, subject to country availability and current terms.
- Reward-eligible videos generally need to be at least 1 minute long and meet quality/originality criteria.
- This creates a strategy split:
  - 20–45s for growth and format discovery.
  - 60–75s for monetization candidates once a format works.

### Instagram / Facebook Reels

Useful for republishing 9:16 assets and testing share/save behavior. Treat direct payout as volatile; prefer indirect monetization through audience, affiliate, newsletter, or products.

### LinkedIn / X / Pinterest

Use selectively:

- LinkedIn: AI/productivity/workflows.
- X: AI demos, build-in-public, technical positioning.
- Pinterest: evergreen checklists, routines, faith/life prompts.

## Repository scaffold

A clean shorts-engine repo can start as:

```text
AutoShortsBot/
  autoshorts/
    config/
    ideas/
    scripting/
    rendering/
    review/
    publishing/
    analytics/
  configs/
    niches/
    platforms/
  data/
    drafts/
    performance/
  scripts/
  tests/
  README.md
  .gitignore
  pyproject.toml
```

Never commit:

- `.env`
- OAuth tokens
- API keys
- generated credentials
- rendered videos or large media outputs unless explicitly intended
- raw analytics exports with sensitive account data

## Implementation quality

When coding the engine, prefer TDD for deterministic parts:

- structured video candidate validation
- testbatch validation and duplicate-id checks
- renderable-candidate filtering before any renderer runs
- candidate factory conversion from raw drafts to validated `VideoCandidate` objects
- duration classification
- stable candidate-id generation and default hashtag derivation
- review formatting
- analytics import
- approval command parsing
- platform metadata generation
- script quality gates

A strong first implementation path is deterministic gating before any renderer exists:

1. Add structured `VideoCandidate` and `TestBatch` models before rendering code. Require candidate id, pillar, title, platforms, duration, hook, script outline, visual concept, caption, CTA, hashtags, quality score, policy notes, and one clear hypothesis.
2. Validate candidates and batches: reject missing strategic fields, unsupported platforms, out-of-range durations, empty batches, and duplicate candidate ids.
3. Add a `ContentPillar` registry and validate candidate pillar/platform fit before review or rendering.
4. Add a deterministic candidate factory: `CandidateDraft → create_candidate() → VideoCandidate`. It should generate stable ids, derive default hashtags, classify duration (`growth_short`, `monetization_candidate`, `experiment`), append the duration class to policy notes, require a hypothesis, and enforce both candidate and pillar-fit validation.
5. Add an approval parser that accepts only explicit commands such as `Freigabe alle`, `Freigabe YouTube`, `Freigabe TikTok`, `Freigabe Instagram`, `Ablehnen`, and `Ändern: <requested change>`.
6. Treat vague consent like `passt schon` as `needs_clarification`; never publish on ambiguous approval.
7. Add a conservative script quality gate before rendering, e.g. average hook/novelty/clarity/retention ≥ 8, AI-slop risk below threshold, and no high policy risk.
8. Add a Telegram review package renderer that surfaces the candidate, gate status, policy notes, preview path, and only relevant platform approval commands.
9. Test these deterministic pieces first with RED-GREEN-REFACTOR before adding renderers, image generation, video generation, or publishing APIs.

Rendering and external API calls can be integration-tested separately.

For this AutoShortsBot/Retention-Studio workflow, prefer a free-first renderer path before any paid video provider: `free_production_jobs → local_motion_renderer → FFmpeg MP4`. The local renderer should use Pillow/FFmpeg procedural motion, mechanism layers, kinetic captions, and generated metadata; preserve exact scene durations from render manifests, exclude text-only LLM refinement jobs from rendering, and keep generated local renders out of git (`data/local_motion_renders/`). NVIDIA/build.nvidia.com LLMs are optional text-refinement helpers only, not video generation.

When Hermes has the `openai-codex` image-generation backend available, GPT Image 2 is a good cloud-side keyframe/thumbnail/concept generator for the pipeline: `script idea → GPT Image 2 keyframe → human review → Wan/ComfyUI I2V or local renderer → deterministic captions/overlays`. Because GPT Image 2 runs cloud-side, it does not compete with local/remote GPU VRAM used by Wan/ComfyUI video jobs. Use low/medium for iteration and high for final keyframes; still add captions, labels, numbers, UI text, and audit-sensitive facts later in the deterministic renderer rather than trusting baked image text.

If the user wants more realistic footage without spending money, first check whether a local GPU/ComfyUI host is available. Preferred path when reachable: `scene spec → ComfyUI/Wan API over Tailscale → imported_ai_clips/<video_id>/scene_XX.mp4 → local captions/mechanism layers/FFmpeg assembly`. For a 16 GB A5000 Laptop GPU, use the `comfyui` skill reference `wan-video-tailscale-a5000.md`: Wan2.1 T2V 1.3B FP8, `--lowvram`, CPU text encoding, VAE tiling, and a small smoke-test ladder before quality probes. If no local GPU path is available or quality is insufficient, use the hybrid free-tier handoff rather than pretending local procedural graphics are realistic: `free_production_jobs → free_ai_video_handoff → manual browser generation in free-tier tools (PixVerse/Pika/CapCut/Hailuo only with existing free credits) → import clips under data/imported_ai_clips/ → local captions/mechanism layers/FFmpeg assembly`. Guardrails: no paid top-ups, no subscriptions, avoid Pro templates, no baked captions/logos/watermarks where possible, and keep imported clips out of git.

For this AutoShortsBot/Retention-Studio workflow, prefer a free-first renderer path before any paid video provider: `free_production_jobs → local_motion_renderer → FFmpeg MP4`. The local renderer should produce moving mechanism/caption previews, not final static cards. When the user has a capable local/remote GPU (e.g. RTX A5000 16 GB via Tailscale), promote the path to `ComfyUI/Wan or LTX local clip generation → imported_ai_clips → hybrid local renderer → FFmpeg`, with free web providers (PixVerse/Pika/CapCut) only as fallback. External free-tier AI video tools can still be used manually for realistic b-roll, but keep paid top-ups/subscriptions disabled and store downloaded clips under `data/imported_ai_clips/<video_id>/scene_XX.mp4`. Generate provider handoff packets for manual browser generation and imported-clip assembly plans so missing clips fall back to local placeholders.

## JARVIS-operated content machine businessplan

When the user asks how the content machine should operate as a business/process, frame it as a **JARVIS-operated, human-approved growth engine**. JARVIS owns ideation, scoring, scripting, preview generation, post metadata, queue maintenance, analytics review, and implementation upkeep. The user should only need to set high-level strategy occasionally and give explicit approval before posting.

For the current TrueTraceShorts setup, phase 1 is manual posting: JARVIS prepares the final video and the complete YouTube/TikTok metadata pack; the user manually uploads/copies it. Later automation may be designed, but only behind the same exact-version approval boundary. TrueTraceShorts should keep its name/handles for phase 1 but reposition around `Systems over prompts.` and mechanism-reveal AI workflow content; see `references/truetrace-branding-manual-posting.md` for the concrete channel description, TikTok bio, manual posting pack shape, and implemented module/API names.

Always describe the pipeline from idea to post with the approval boundary visible:

```text
Research -> Idea -> Strategy Score -> Script -> Quality Gate -> Preview -> Social Draft -> Approval Package -> Human Approval -> Final Render -> Manual Posting Pack -> User Manual Upload -> Analytics -> Next Batch
```

The plan should cover descriptions/captions, hashtags/tags, platform metadata, daily volume policy, branding, and what input is still needed from the user. See `references/jarvis-content-machine-businessplan.md` and `references/truetrace-branding-manual-posting.md` for condensed operating notes.

## Strategy gates for follower conversion

When designing or scoring candidates, optimize for the full viewer path:

1. **Stop:** first 1–3 seconds create novelty, contradiction, visual anomaly, or a specific curiosity gap.
2. **Stay:** every 3–5 seconds opens or resolves a clear loop; fast cuts alone are not retention.
3. **Feel:** the candidate targets a concrete emotion such as relief, awe, frustration, identity pride, or amusement.
4. **Trust:** the video contains specificity, proof, tradeoffs, source-backed examples, or transparent reasoning.
5. **Follow:** the viewer can predict what future value this account will provide and why this worldview is distinct.

Prefer fields/gates such as `hook_type`, `first_2_seconds`, `curiosity_gap`, `viewer_identity`, `target_emotion`, `share_reason`, `future_value_promise`, and `follow_reason` before rendering.

Use **variety inside a stable promise**, not random topic hopping:

- 70% proven repeatable formats
- 20% controlled variations
- 10% experiments

Stable: worldview, tone, visual grammar, quality standard, and audience promise. Vary: hook type, payoff type, emotional lane, examples, format family, and visual layer.

Good initial public-safe series families for this user's JARVIS-operated content machine:

- `AI System Autopsy` — problem → cause → system fix → result.
- `Prompt vs System` — fragile prompt hack vs repeatable system.
- `One Rule, One Example` — one principle demonstrated with one concrete use case.
- `AI Hype Court` — claim → evidence → verdict → better action.

Do **not** assume AI-workflow content will work just because AI is popular. The user explicitly challenged this: the space is saturated, and generic AI tips are weak. Before rendering at scale, create a concrete 5-concept testbatch with hooks, outlines, visual mechanism plans, YouTube/TikTok metadata, and hypotheses so the user can judge whether the direction is actually promising. Treat the first batch as an experiment; if retention/follows are weak, pivot instead of defending the niche.

After the user accepts a direction, make the next proof tangible: select the strongest 3 concepts and build local MP4 timing previews plus approval/manual-upload packages. Keep this as a side-effect-separated preview pipeline, e.g. `Candidate -> ScriptDraft -> ShotPlan -> RenderManifest -> LocalPreviewPlan -> PNG scene cards -> FFmpeg MP4 timing preview -> SocialMediaDraft -> ContentPreviewApprovalPackage -> ManualPostingPack`. Resolve preview output directories to absolute paths before creating FFmpeg concat plans to avoid relative-path duplication inside concat-file rendering. See `references/shorts-subtitles-tts-preview-packages.md`.

Hard no-go for public content: never make videos about JARVIS/Hermes, the user, their collaboration, private/behind-the-scenes material, politics, legally sensitive loopholes, rule-bypassing, private-data misuse, morally objectionable exploitation, or anything that could enable lawbreaking. JARVIS operation is an internal production model, not a public content angle.

## Pitfalls

- **Generic advice content:** “4 tips to be healthier/productive” is usually too weak unless the hook, identity, or story is sharp.
- **Generic AI tips positioning:** if a video could belong to any AI tips account, penalize it. Protect the differentiator: systems over prompts, transparent constraints, mechanism-first visuals, and safe public artifacts. Do not turn JARVIS/the user/the collaboration into public content.
- **Premature niche confidence:** when the user questions whether AI content is saturated, do not reassure vaguely. Produce concrete test concepts and hypotheses, then propose a small preview batch and analytics-based pivot criteria.
- **AI-image slop:** avoid generated images containing fake UI text, gibberish signs, distorted hands/faces, or abstract generic graphs. These damage trust fast.
- **Too much automation too soon:** validate scripts and formats before building posting APIs.
- **No analytics loop:** producing content without tracking retention, likes, shares, comments, and follows is blind output.
- **Format fatigue:** repetition creates familiarity, but identical hook/payoff/visual patterns across consecutive videos become template spam. Track recent similarity before scaling daily volume.
- **Mixed language drift:** decide language per channel or per pillar before rendering. Mixed English/German drafts are fine for ideation, not final voiceover unless intentional.
- **Baked caption text:** do not rely on AI-generated images/videos for subtitles, labels, UI text, or facts. Use renderer-owned captions/overlays so errors remain editable and brand-safe.
- **GPU contention from local TTS:** for early Shorts production, prefer non-GPU TTS such as EdgeTTS for the baseline while the GPU is needed for ComfyUI/Wan/Qwen image/video work. Treat NVIDIA Magpie or local TTS as A/B candidates, not defaults, until voice quality, cost, and operational reliability are proven.
- **Whisper confusion:** Whisper is STT/alignment/QA, not TTS. Use it later to verify spoken audio and subtitle timing; do not select it as the voice-generation model.

## References

- `references/autoshortsbot-case-study.md` — case-study details from the AutoShortsBot setup: first testbatch shape, repo scaffold, and approval loop.
- `references/approval-first-bot-foundation.md` — implementation pattern for the first safe bot slice: explicit approval parser, quality gate, Telegram review package, and TDD test shape.
- `references/idea-candidate-testbatch-foundation.md` — deterministic `VideoCandidate`/`TestBatch` foundation before rendering: validation rules, renderable filtering, and test shape.
- `references/content-pillar-registry-foundation.md` — strategic `ContentPillar` registry pattern: default `ai_life_systems`, pillar/candidate fit validation, and TDD test shape.
- `references/candidate-factory-foundation.md` — deterministic `CandidateDraft → create_candidate() → VideoCandidate` layer: stable ids, duration classes, default hashtags, hypothesis requirement, and tests.
- `references/jarvis-operated-content-machine.md` — session-derived strategy notes for a JARVIS-operated, human-approved content machine: hook/follower psychology, variety vs identity, series families, and next implementation gates.
- `references/jarvis-content-machine-businessplan.md` — business/process plan for a JARVIS-operated content machine: idea-to-post pipeline, minimal user role, approval boundary, metadata generation, daily volume policy, and strategy scoring gate.
- `references/truetrace-branding-manual-posting.md` — TrueTraceShorts-specific brand positioning and phase-1 manual posting handoff: YouTube description, TikTok bio, visual direction, metadata pack shape, and no-go boundaries.
- `references/truetrace-concept-testbatch.md` — concrete 5-concept TrueTraceShorts testbatch pattern for validating saturated AI-workflow positioning before rendering at scale.
- `references/shorts-subtitles-tts-preview-packages.md` — top-3 timing preview package pattern, FFmpeg relative-path pitfall, Hormozi-inspired renderer-owned captions, and EdgeTTS/Magpie/Whisper TTS guidance.


social-shorts-growth-engine

---
name: social-shorts-growth-engine
description: Plan and build automated short-form video growth pipelines for YouTube Shorts, TikTok, Instagram Reels, and similar channels with retention-led ideation, human approval, and analytics feedback.
version: 1.0.0
---

# Social Shorts Growth Engine

Use this skill when building or improving systems that generate, review, render, or publish short-form social videos, especially automated/faceless pipelines for YouTube Shorts, TikTok, Instagram Reels, or cross-platform repurposing.

## Core principle

Do **not** treat the project as merely a video generator. Treat it as a growth engine:

1. Research what the platform currently rewards.
2. Generate hypotheses for hooks/formats/niches.
3. Score ideas before rendering.
4. Produce reviewable drafts/previews.
5. Require human approval before posting.
6. Capture analytics and feed winners back into the next batch.

## Default workflow

1. **Load project constraints**
   - Channel/topic/session boundaries.
   - Existing code locations and repo.
   - Secret-handling rules.
   - User’s desired niches and no-go topics.

2. **Research current platform rules**
   - Prefer official/near-official sources: YouTube Help, TikTok Creator Academy/Terms, Meta docs.
   - Record only durable rules in a concise reference file, not full scraped pages.
   - Verify monetization details before recommending video lengths.

3. **Define content pillars**
   - Keep pillars distinct enough to measure.
   - Avoid mixing sensitive identity topics with AI/automation unless the user explicitly wants that brand strategy.
   - If the user says a pillar is “heikel”/sensitive, pause it in config rather than deleting it, with a reason and revisit condition.

4. **Build a test batch**
   - Start with 6–12 ideas, not dozens of rendered videos.
   - Include a mix of growth candidates and monetization-length candidates.
   - For TikTok Rewards experiments, include selected 61–75s candidates only after hook strength is high.
   - For growth, prefer 25–45s candidates.

5. **Score before rendering**
   Score ideas on:
   - direct self-relevance in first 1–2 seconds
   - open loop
   - specificity
   - tension/contrarian angle
   - concrete payoff
   - visual pattern interrupt
   - comment/conversation trigger
   - niche authority
   - policy/brand risk

6. **Generate Telegram/human review packages**
   Each draft/preview should include:
   - title
   - duration
   - platform targets
   - hook
   - script draft or final voiceover
   - visual concept
   - caption/hashtags
   - quality/retention score
   - risks/policy notes
   - approval commands

7. **Do not auto-post until approved**
   Use explicit approval commands such as:
   - `Freigabe alle`
   - `Freigabe YouTube`
   - `Freigabe TikTok`
   - `Freigabe Instagram`
   - `Ablehnen`
   - `Ändern: ...`

8. **Analytics loop**
   After posting, track at least:
   - platform
   - pillar/niche
   - format
   - hook
   - duration
   - views after 2h/24h/7d
   - likes/comments/shares/follows
   - retention/average watch time if available

## Retention heuristics

People tend to stop scrolling for:

- **Immediate self-relevance:** “If your brain has 47 tabs open…”
- **Open loops:** “do this before…”, “why…”, “stop…”, “not…”
- **Specificity:** numbers, named tools/platforms, concrete situations.
- **Tension:** challenges a common belief without cheap outrage.
- **Concrete payoff:** template, prompt, before/after, exact step.
- **Visual pattern interrupt:** movement/change in the first seconds, not static AI art.
- **Conversation trigger:** specific question or keyword CTA.
- **Niche authority:** a recognisable point of view, not generic advice.

Reject or revise drafts with:

- “In this video…” slow intros.
- generic “4 tips” without a fresh angle.
- pure slideshow/static visuals.
- abstract AI backgrounds that do not communicate the hook.
- AI-gibberish UI/text artifacts.
- broad advice with no visible payoff.

## Monetization notes

Always re-check current official docs before major platform decisions. Current durable operating assumptions:

- YouTube Shorts can be vertical/square and up to 3 minutes.
- YouTube Shorts YPP path has historically required 1,000 subscribers plus large valid Shorts-view thresholds in a recent period.
- TikTok Creator Rewards has historically rewarded original, high-quality videos longer than 1 minute and required account eligibility such as follower/view thresholds and good standing in selected countries.
- TikTok’s reward-eligible content should avoid low-quality patterns: copied/minimally altered work, meaningless reactions, blurry visuals, pure slideshows, clickbait without value, and policy-risky content.

See `references/retention-and-monetization-notes.md` for concise notes from the AutoShortsBot session.

## Implementation patterns

For repositories that generate shorts:

- Keep secrets, generated media, `.env`, and credentials out of Git.
- Store test batches as structured data under `data/drafts/`.
- Store human-review drafts under `data/reviews/` if they are lightweight text.
- Add validation tests for batch shape and required fields.
- Add heuristic retention scoring before rendering.
- Treat rendering as later-stage; validate scripts and hooks first.

## Pitfalls

- Do not immediately render all ideas. First validate hooks, scripts, and review format.
- Do not assume a niche is safe because it is popular. Sensitive topics can confuse brand positioning when mixed with AI/automation.
- Do not rely on platform tags/hashtags as the growth strategy. Hooks, retention, satisfaction, and niche fit matter more.
- Do not post automatically from an agent without explicit approval and a side-effect boundary.
- Do not print or commit tokens from Google Drive or local secret files.


Explanation:
**Preparing for the next video**

I need to respond to the user’s request for the next video. It seems I should check the repository and files. I should also consider previous feedback about syncing subtitles and ensuring a solid conclusion. I’ll likely build the next video in the current project directory, hermes-agent, while looking for necessary outputs and scripts. Using a to-do list might help organize everything, and I'll figure out how to load references dynamically while resetting proof.


social-media-shorts-automation

# Static active-word captions + controlled final pilot render

Session learning from the first TrueTraceShorts pilot (`AI Output Autopsy / Meeting Summary Decision Target`). Use this for final-near preview/final render work where the user reviews voiceover, subtitle feel, Wan/background quality, and anti-AI-slop risk.

## Caption style correction

The user explicitly rejected two subtitle behaviours:

1. **One word shown alone** — too nervous / teleprompter-like.
2. **Sliding word window where all visible words change at once** — still too jumpy.

Required default style for this user's AutoShorts/TrueTraceShorts videos:

```text
static phrase segment + active-word highlight
```

Rules:

- Keep the subtitle phrase segment static on screen.
- Show at least 3 words at once; ideal is 4–7 words when the phrase allows it.
- Words stay in the same positions during the segment.
- Only the currently spoken word highlights / pulses.
- The highlight moves left-to-right through the fixed phrase.
- Replace the whole phrase only at the next sentence/phrase boundary.
- Do not default to one-word-only captions except for a deliberate hook/impact frame.
- Do not use hectic windows where all words change at once every word.

Implementation pattern:

```text
word cues → phrase segments of 3–7 words → fixed layout per segment → active_word_index selects highlight only
```

Logic tests to add for any renderer implementation:

- static caption segment contains multiple words
- active word changes within the same segment
- segment text remains stable while highlight moves
- no one-word-only caption mode as default when enough words exist

## Preview/final render gate sequence

Use approval states as resource gates, not as vague comments:

- `APPROVED_FOR_PREVIEW_RENDER` permits TTS, subtitle alignment, deterministic animatic/preview MP4, and Telegram delivery of that preview only.
- `APPROVED_FOR_FINAL_RENDER` permits exactly the approved final render resource tier for the hash/version-bound candidate.
- Publishing/platform APIs remain blocked until a separate manual-posting approval.
- AI image/keyframe generation remains blocked unless separately approved.

Before final render, verify:

- candidate_id matches
- version matches
- script_hash matches
- claim gate valid
- AI disclosure valid
- resource gate allows only the intended render tier
- publishing and platform API tiers still block

## Wan/background policy for this class

For a controlled pilot final render, Wan may generate only a **text-free visual motion/background layer**. Deterministic renderer must own:

- captions
- labels
- arrows
- stamps such as `USELESS`
- mechanism diagrams
- factual claims / UI-like text
- final takeaway text

Wan negative prompt must include variants of:

```text
readable text, words, subtitles, captions, numbers, logos, watermark, brand names, UI text, fake letters
```

If constrained to exactly one Wan render, it is acceptable to create one short text-free Wan background clip and loop/upscale/compose it under deterministic overlays, but label that limitation clearly in the review package. Do not silently imply that every scene was separately generated.

## Review package checklist

After final pilot render, produce:

- final MP4 path
- SHA256
- duration, resolution, fps
- audio path and measured duration
- subtitle/caption path
- render manifest
- Wan prompt plan/history/log
- claim gate result
- AI disclosure result
- resource gate result
- known limitations, especially forced-alignment status and any looped background layer
- draft social copy and manual posting pack marked draft-only
- explicit note: no posting, no platform API, no second final render without approval

## Pitfall

Do not treat a caption-style correction as a one-off `/tmp` script patch. Integrate the behaviour into the actual renderer/caption library and commit tests so the next render starts from the corrected style.


# Proof Short Real-Problem Reset

Use this when an early short/pilot looks increasingly polished but still fails because viewers cannot see a real problem in the first second.

## Trigger

Switch to this mode when the user says a pilot is:

- pretty but semantically empty
- too abstract or generic
- missing a visible fail / real viewer pain
- overproduced before the format is validated
- relying on AI images, Wan/I2V, glassmorphism, or B-roll as the story carrier

## Archive the old candidate first

Mark the old candidate as a paused learning case, not a render target.

Recommended archive fields:

```json
{
  "status": "paused_learning_case",
  "reason": "Pretty but semantically weak. Too abstract for first pilot. Visuals do not create immediate viewer pain or retention.",
  "do_not_continue": {
    "further_optimization": false,
    "rendering": false,
    "posting": false,
    "wan": false,
    "i2v": false,
    "platform_api": false
  }
}
```

Postmortem structure:

- Worked: approval gates, clean captions, delivery discipline, workflow/styleframe learning, technical I2V sanity where applicable.
- Failed: topic too abstract, no visible fail, too much production before validation, too many visual metaphors, AI video/image generation used too early as story carrier.
- New rule: `Pretty Empty Visual Blocker`.

## Pretty Empty Visual Blocker

Block a candidate or visual plan if:

- the image is high-quality but does not show a clear problem without voiceover
- no visible fail exists
- the visual is only mood/B-roll
- the viewer cannot tell within 1 second what is at stake
- usefulness only emerges through abstract explanation
- the scene is interchangeable with dozens of other AI/productivity videos

A visual plan must answer:

1. What is concretely broken?
2. Where can the viewer see the error?
3. What is at stake for the viewer?
4. Which simple rule repairs it?
5. Why would someone save or share this?

## ProofShortMode defaults

Proof Shorts are the default for the first 10–20 unvalidated videos.

- 25–35 seconds
- screen/mockup-led or real-problem-led
- no Wan final
- no I2V/T2V full render
- no premium styleframe pass
- no abstract metaphors
- no AI B-roll as main visual
- fast useful preview to validate topic/format
- manual approval before any posting pack

Premium episodes come only after the theme/format is proven by viewer response.

## Good first Proof Short shape

For digital safety/workflow/AI-mechanism content:

```text
visible fail → recognition → mechanism → simple check/rule → safe next action → memorable takeaway
```

Example topic class: fake invoice/payment-route red flag.

- Use controlled fictional mockups.
- Show invoice/email/payment route in the first frame.
- Avoid real brands, addresses, IBANs, QR codes, logos, and real people.
- Use renderer-owned UI text/highlights; do not use real scam templates.
- Keep claims as general safety advice, not legal/financial advice.

## Caption style

Keep the user's corrected style:

- static phrase segments
- active-word highlight
- white inactive words
- yellow active word
- no frame/box/full-width bar/dark subtitle block
- subtle shadow or outline only
- mobile-safe bottom position

## ReviewPackageV2 additions

For Proof Shorts include:

- `ProofShortMode = true`
- selected hook plus hook variants
- script
- visual plan
- Pretty Empty Visual Blocker result
- claim gate
- AI disclosure
- save/share/follow reasons
- platform fit
- preview MP4 path, SHA256, duration, resolution
- Telegram delivery status

## Hard blocks until approval

Do not run:

- Wan/I2V/T2V full render
- full-final render
- platform API
- auto-posting
- scheduling
- render series

Allowed next commands should be explicit, e.g.:

```text
APPROVED_PROOF_SHORT <candidate_id>
REVISE_PROOF_SHORT <candidate_id> <field> "Änderungswunsch"
REJECT_PROOF_SHORT <candidate_id> "Grund"
APPROVED_FOR_MANUAL_POSTING_PACK <candidate_id>
```


# Proof Short AI Visual Upgrade Pattern

Use this when a Proof Short concept is approved as useful/clear, but the user asks why it does not use AI images to make the video look more premium.

## Core decision

Do not treat `ProofShortMode` as `no AI visuals forever`. Treat it as:

```text
validate real viewer problem first → then optionally add AI polish without surrendering factual/UI control
```

For security, finance, scam-awareness, invoice, email, payment-route, medical, or other high-trust topics, distinguish between:

- **factual/semantic assets**: UI, invoice, email, payment route, numbers, labels, warnings, claims, routing/account fields. These stay deterministic and renderer-owned.
- **atmospheric/premium assets**: desk, laptop, office, screen glow, neutral background, product-film texture, cover/thumbnail background, text-free keyframes. These may use AI image generation after the concept is validated.

## Recommended upgrade mode

```text
mode: ai_background_plus_deterministic_mockups
provider: openai-codex
model: highest available reasonable GPT Image tier, usually gpt-image-2-high
outputs: 2–3 text-free background/keyframes
renderer remains source of truth for all readable text/facts
```

Use this to make a Proof Short look less flat without turning it into an uncontrolled AI-image story.

## Safe AI image uses

Good uses:

- cinematic desk/laptop/office background
- neutral invoice-review atmosphere with blank papers/screens
- second-channel verification mood/background
- thumbnail/cover background
- premium lighting and product-film texture
- subtle abstract security atmosphere if it still supports the visible real problem

Bad uses:

- generating the invoice itself
- generating the email UI itself
- generating bank/payment details, account fields, IBANs, QR codes, barcodes, addresses, logos, fake company marks, legal text, or claims
- using AI image text as part of the message
- letting AI-generated visuals replace the visible fail/fix logic

## Prompt constraints

Every AI image prompt should say:

- text-free image
- no readable text
- no logos or brands
- no QR codes/barcodes
- no real companies, banks, people, addresses, account numbers, invoice numbers, or payment details
- leave clean safe space for renderer-owned captions and UI overlays
- realistic/premium social-video keyframe, 9:16
- show atmosphere/problem context, not factual content

## Review package additions

When using this upgrade, include:

- `visual_upgrade_mode: ai_background_plus_deterministic_mockups`
- AI image provider/model/quality
- number of generated keyframes
- number of used keyframes
- number of discarded keyframes and explicit discard reasons
- per-image SHA256/path/resolution
- statement that UI/invoice/payment route remained deterministic
- no Wan/I2V/full-final unless separately approved
- whether AI disclosure is required or only conservative optional disclosure

## Operational QA note

After generation, make a small contact sheet and inspect it before rendering. Do not use every image automatically. Discard AI backgrounds that contain pseudo-readable document lines, logo-like marks, QR/barcodes, people/hands, bank/payment details, or busy compositions that fight the deterministic foreground. For render treatment, keep AI backgrounds subordinate: slight blur/push-in/dark overlay is preferable to letting image detail compete with captions or the visible fail. See `references/proof-short-ai-background-rendering-qa.md` for the concrete pattern.

## Pitfall

Do not answer the user's “why no AI images?” as if AI images are forbidden. The correct answer is: AI images are useful for premium atmosphere after the proof concept is validated, but not for the factual invoice/email/payment-route layer. Offer a small controlled visual-upgrade pass instead of defending a flat deterministic preview.


Explanation:
**Inspecting video files**

I need to inspect the current repository, hermes-agent, for files related to "shorts." Maybe I should search in the tmp directory. It seems like we want to create a concept or scripts for the next video without necessarily rendering it. The term "erarbeite" implies developing the next video. I'll probably generate a candidate review package instead of doing a full render. I'll look for recent outputs in /tmp/autoshorts and check the pipeline scripts.

todo

Letztes Feedback in Anforderungen für nächstes Video übersetzen

Vorhandene AutoShorts/Proof-Short Artefakte und Pipeline finden

Nächstes Video als ReviewPackage mit Hook, Script, Visualplan, Fazit und Caption-Sync-Regel ausarbeiten

ReviewPackage/Entwurf knapp an User liefern und nächste Freigabe-Kommandos nennen


terminal

python - <<'PY'
from pathlib import Path
for p in Path('/tmp').glob('autoshorts*'):
    print(p)
PY


Output:
/tmp/autoshorts_push3.log
/tmp/autoshorts_push13.log
/tmp/autoshorts_review
/tmp/autoshorts-demo-delivery.txt
/tmp/autoshorts_push9.log
/tmp/autoshorts_premium_styleframes_sprint22
/tmp/autoshortsbot_businessplan
/tmp/autoshorts_clean_image_cut_sprint25
/tmp/autoshorts_ai004_frames_new
/tmp/autoshorts_i2v_sprint2_sanity
/tmp/autoshorts_git_clone.log
/tmp/autoshorts_proof_short_sprint30
/tmp/autoshorts_push.log
/tmp/autoshorts-demo-local-preview-de
/tmp/autoshorts_push7.log
/tmp/autoshorts_push11.log
/tmp/autoshorts_push2.log
/tmp/autoshorts-social-draft.txt
/tmp/autoshorts-demo-review.txt
/tmp/autoshorts_real_life_styleframes_sprint23
/tmp/autoshorts_push4.log
/tmp/autoshortsbot_strategic_inputs.md
/tmp/autoshorts_i2v_sprint2_audit
/tmp/autoshorts_preview_check
/tmp/autoshortsbot_strategy_update
/tmp/autoshorts_push8.log
/tmp/autoshorts_final_v1
/tmp/autoshorts_hybrid_layout_sprint21
/tmp/autoshorts_ffmpeg.log
/tmp/autoshorts_ai004_frames_old
/tmp/autoshorts_push12.log
/tmp/autoshorts_push10.log
/tmp/autoshorts_comfy_check
/tmp/autoshorts_push5.log
/tmp/autoshorts_styleframes_sprint2
/tmp/autoshorts_push6.log
/tmp/autoshorts_visual_proof_v1
/tmp/autoshorts_ffmpeg2.log
/tmp/autoshorts_clip_contact
/tmp/autoshorts_prerelease_animatic_sprint24
/tmp/autoshorts_keyframe_proof_v2
/tmp/autoshorts-demo-local-preview
/tmp/autoshorts-render-preview.html
/tmp/autoshorts_preview_v2


Explanation:
**Inspecting sprint30 files**

I need to take a closer look at the sprint30 files. There must be details or progress notes I need to check to ensure everything is in order. I'm thinking about focusing on specific sections that might need my attention. I want to make sure I catch any issues early on, so a careful inspection seems like the right move. Let's dive in and see what I find!


Explanation:
**Developing the next video concept**

I need to create the next video, possibly using a new script. The user mentioned "erarbeite," suggesting I develop something without necessarily rendering it fully. I might choose a relevant topic, like "Fake DocuSign/SharePoint link" or "AI meeting summary isn't proof," related to digital scams. I should generate a JSON/Markdown file for the script, incorporating both English and German. There might also be options to use tools for rendering previews.
**Creating a pre-render package**

I might create a pre-render package even if it’s not a full video. The user’s request for a "next video" suggests they want an actual production pipeline. I don’t have current scripts, but I can adapt an existing render script. The instructions urge me to take action, not just plan, so I could write the package and send a final summary. I also need to consider inspecting previous script formats for alignment.


     1|{
     2|  "hooks": {
     3|    "problem_hook": "This invoice looks normal. The trap is not the logo \u2014 it\u2019s the payment route.",
     4|    "red_flag_hook": "A fake invoice does not need a fake logo. It only needs a changed payment route.",
     5|    "save_share_hook": "Before anyone on your team pays an invoice, check this one red flag."
     6|  },
     7|  "selected_hook": "This invoice looks normal. The trap is not the logo \u2014 it\u2019s the payment route.",
     8|  "script": "This invoice looks normal. The trap is not the logo \u2014 it\u2019s the payment route. Same layout. Same professional tone. Same urgency. But one thing changed: where the money goes. Before you pay, check three things: sender domain, urgency language, and payment route. If the route changed, don\u2019t pay from the email. Verify through a second channel. Urgency is not proof. It\u2019s the red flag.",
     9|  "duration_target_seconds": "28-35"
    10|}


     1|{
     2|  "candidate_id": "digital-red-flags-fake-invoice-payment-route-30s",
     3|  "production_mode": {
     4|    "mode": "proof_short",
     5|    "min_duration_seconds": 25,
     6|    "max_duration_seconds": 35,
     7|    "screen_or_real_problem_led": true,
     8|    "wan_final_allowed": false,
     9|    "premium_styleframe_pass_allowed": false,
    10|    "abstract_metaphors_allowed": false,
    11|    "goal": "Validate format/topic with a fast useful preview before premium production."
    12|  },
    13|  "hook_variants": {
    14|    "problem_hook": "This invoice looks normal. The trap is not the logo \u2014 it\u2019s the payment route.",
    15|    "red_flag_hook": "A fake invoice does not need a fake logo. It only needs a changed payment route.",
    16|    "save_share_hook": "Before anyone on your team pays an invoice, check this one red flag."
    17|  },
    18|  "selected_hook": "This invoice looks normal. The trap is not the logo \u2014 it\u2019s the payment route.",
    19|  "script": "This invoice looks normal. The trap is not the logo \u2014 it\u2019s the payment route. Same layout. Same professional tone. Same urgency. But one thing changed: where the money goes. Before you pay, check three things: sender domain, urgency language, and payment route. If the route changed, don\u2019t pay from the email. Verify through a second channel. Urgency is not proof. It\u2019s the red flag.",
    20|  "script_hash": "c8f105c8faae7d77",
    21|  "visual_plan": {
    22|    "format": "ProofShortMode screen/mockup-led motion short, 9:16",
    23|    "scenes": [
    24|      {
    25|        "id": "s01_visible_fail",
    26|        "time": "0-2s",
    27|        "visual": "fake email + invoice mockup appears; payment route line is present but not yet highlighted",
    28|        "purpose": "instant visible real-world pain"
    29|      },
    30|      {
    31|        "id": "s02_same_layout",
    32|        "time": "2-7s",
    33|        "visual": "invoice/email comparison shows same clean layout, tone, urgency chip; no brands/real data",
    34|        "purpose": "recognition and tension"
    35|      },
    36|      {
    37|        "id": "s03_route_changed",
    38|        "time": "7-14s",
    39|        "visual": "payment route card changes from known route to new route; yellow/red highlight, no real IBAN",
    40|        "purpose": "mechanism reveal"
    41|      },
    42|      {
    43|        "id": "s04_three_checks",
    44|        "time": "14-24s",
    45|        "visual": "three checklist cards: sender, urgency, payment route",
    46|        "purpose": "useful saveable rule"
    47|      },
    48|      {
    49|        "id": "s05_second_channel",
    50|        "time": "24-31s",
    51|        "visual": "email pay button dims; second-channel verify card appears",
    52|        "purpose": "safe action"
    53|      },
    54|      {
    55|        "id": "s06_takeaway",
    56|        "time": "31-35s",
    57|        "visual": "final clean red-flag rule card with fake invoice in background",
    58|        "purpose": "memorable takeaway"
    59|      }
    60|    ],
    61|    "renderer_owned": [
    62|      "all mockup text",
    63|      "highlights",
    64|      "check cards",
    65|      "captions",
    66|      "red/yellow warning moment"
    67|    ],
    68|    "forbidden": [
    69|      "real brands",
    70|      "real bank data",
    71|      "IBANs",
    72|      "QR codes",
    73|      "real people",
    74|      "real addresses",
    75|      "scam template details"
    76|    ],
    77|    "style": "controlled fictional UI/document mockup, mobile-readable, high contrast, calm motion, no AI image generation required"
    78|  },
    79|  "pretty_empty_visual_blocker_result": {
    80|    "is_valid": true,
    81|    "errors": []
    82|  },
    83|  "claim_gate": {
    84|    "claim_type": "general safety advice / low-to-medium risk",
    85|    "risk": "medium",
    86|    "result": "pass",
    87|    "safe_phrasing": [
    88|      "A common red flag is\u2026",
    89|      "Before you pay, check\u2026",
    90|      "Verify through a second channel."
    91|    ],
    92|    "not_claimed": [
    93|      "all fake invoices work this way",
    94|      "three checks prevent all scams",
    95|      "legal or financial advice"
    96|    ],
    97|    "abuse_controls": [
    98|      "no real bank data",
    99|      "no real companies",
   100|      "no real logos",
   101|      "no real QR codes",
   102|      "no operational scam template"
   103|    ]
   104|  },
   105|  "ai_disclosure": "no: deterministic mockups and TTS preview; no realistic AI-generated people/scenes",
   106|  "proof_short_mode": true,
   107|  "review_package_v2": {
   108|    "candidate_id": "digital-red-flags-fake-invoice-payment-route-30s",
   109|    "version": "v3.0.0",
   110|    "script_hash": "af457e73844be4f7",
   111|    "media_hash": null,
   112|    "series": "Digital Red Flags",
   113|    "audience_need": "safety",
   114|    "emotion_before": "anxious",
   115|    "emotion_after": "warned",
   116|    "hook": "This invoice looks normal. The trap is not the logo \u2014 it\u2019s the payment route.",
   117|    "first_frame": "Fake invoice email with normal layout vs. red flag payment route warning in the payment section.",
   118|    "visible_fail": "The invoice looks professional, but the payment route changed under urgency.",
   119|    "anti_example": "A normal-looking invoice where the route changed and urgency pressures payment.",
   120|    "concrete_scene": "fictional email invoice/payment route mockup on a phone-like vertical screen",
   121|    "mechanism": "Fake payment requests can reuse familiar layout and pressure while moving the money route.",
   122|    "fix": "Before paying, check sender domain, urgency language, and payment route; if the route changed, verify through a second channel.",
   123|    "before_after": "Before: trusted the logo and urgency. After: checked route change and verified outside the email.",
   124|    "takeaway": "Urgency is not proof. It is the red flag.",
   125|    "save_reason": "Save the three-check invoice rule before paying from email.",
   126|    "share_reason": "Share with teammates or family who receive invoices and payment requests.",
   127|    "follow_reason": "Follow for digital red flags before they cost you.",
   128|    "claims": [
   129|      "Payment-route changes and urgency language are common red flags worth verifying before payment."
   130|    ],
   131|    "claim_risk": "medium",
   132|    "ai_disclosure": "no",
   133|    "platform_fit": {
   134|      "youtube_shorts": "strong: useful safety rule with visible first-frame fail",
   135|      "tiktok": "strong: red-flag hook and shareable warning",
   136|      "instagram_reels": "medium-strong: clean mockup and saveable checklist",
   137|      "linkedin_manual": "strong for workplace teams; manual caption only"
   138|    },
   139|    "linkedin_title": "The invoice red flag teams miss",
   140|    "linkedin_caption": "A fake invoice does not need a fake logo. Before paying from email, check sender domain, urgency language and payment route \u2014 then verify route changes through a second channel.",
   141|    "risks": [
   142|      "avoid real brands/bank data/QR codes",
   143|      "avoid implying the checklist prevents all scams",
   144|      "not legal or financial advice"
   145|    ],
   146|    "experiment_hypothesis": {
   147|      "statement": "Tests whether concrete digital-safety red flags create saves and shares better than abstract AI workflow content.",
   148|      "expected_winning_metric": "saves_per_view"
   149|    },
   150|    "expected_winning_metric": "saves_per_view",
   151|    "human_texture_note": "common workplace invoice/payment request scenario using fully fictional mockups",
   152|    "render_backend_candidate": "python_motion",
   153|    "score": {
   154|      "total": 87,
   155|      "render_allowed": true,
   156|      "reject_reasons": [],
   157|      "breakdown": {
   158|        "problem_urgency": {
   159|          "points": 13,
   160|          "max_points": 15,
   161|          "rationale": "Visible everyday fail with recognizable audience need."
   162|        },
   163|        "first_frame_clarity": {
   164|          "points": 10,
   165|          "max_points": 12,
   166|          "rationale": "First frame shows a conflict without relying on audio."
   167|        },
   168|        "hook_curiosity": {
   169|          "points": 10,
   170|          "max_points": 12,
   171|          "rationale": "Hook opens a mechanism loop; generic hooks lose points."
   172|        },
   173|        "mechanism_value": {
   174|          "points": 11,
   175|          "max_points": 12,
   176|          "rationale": "Mechanism is tied to anti-example/concrete scene."
   177|        },
   178|        "practical_payoff": {
   179|          "points": 13,
   180|          "max_points": 15,
   181|          "rationale": "Fix and takeaway are actionable."
   182|        },
   183|        "retention_path": {
   184|          "points": 8,
   185|          "max_points": 10,
   186|          "rationale": "Before/after plus motion-led path."
   187|        },
   188|        "share_save_potential": {
   189|          "points": 9,
   190|          "max_points": 10,
   191|          "rationale": "Save, share, and follow reasons are explicit."
   192|        },
   193|        "human_texture": {
   194|          "points": 8,
   195|          "max_points": 8,
   196|          "rationale": "Concrete human texture, not just an enum."
   197|        },
   198|        "series_fit": {
   199|          "points": 4,
   200|          "max_points": 4,
   201|          "rationale": "Known TrueTrace series."
   202|        },
   203|        "saturation_defense": {
   204|          "points": 1,
   205|          "max_points": 2,
   206|          "rationale": "Saturation risk penalty applied."
   207|        }
   208|      }
   209|    },
   210|    "approval_command": "APPROVE digital-red-flags-fake-invoice-payment-route-30s v3.0.0 af457e73844be4f7"
   211|  },
   212|  "review_package_valid": {
   213|    "is_valid": true,
   214|    "errors": []
   215|  },
   216|  "preview_mp4_path": null,
   217|  "telegram_delivery_status": null,
   218|  "blocked": {
   219|    "wan": true,
   220|    "i2v": true,
   221|    "full_final": true,
   222|    "posting": true,
   223|    "platform_api": true,
   224|    "scheduling": true
   225|  }
   226|}