youtube-script-writer
- Repo stars 834
- Author updated Live
- Author repo boop-agent
- Domain
- Productivity
- Compatible agents
-
- Claude Code
- Cursor
- Cline
- Codex
- Windsurf
- Gemini CLI
- +20
- Trust score
- 88 / 100 · community maintained
- Author / version / license
- @raroque · no license declared
- Token usage
- Lean
- Setup complexity
- Plug-and-play
- External API key
- Not required
- Operating systems
- Unspecified (assume cross-platform)
- Runtime requirements
- No special requirements
- Permissions
-
- Read-only
- Write / modify
- Network behavior
- Local-only
- Install commands
- 26 variants
Profile is derived at build time from SKILL.md and install vectors. Subject to drift from author intent.
Heads up: 未限定 allowed-tools，默认拥有全部工具权限。
---
name: youtube-script-writer
description: Write a tight, retention-focused YouTube script from a topic, outline, or research brief. Use wh…
category: productivity
runtime: no special runtime
---
# youtube-script-writer output preview
## PART A: Task fit
- Use case: Write a tight, retention-focused YouTube script from a topic, outline, or research brief. Use when the user asks for a video script, wants to turn notes or research into a YouTube video, needs a hook/intro rewritten, or wants to plan a video end-to-end with pacing, visual beats, and CTAs..
- Inputs: target material, constraints, expected output, and acceptance criteria.
- Evidence boundary: follow “When to use / When NOT to use / Inputs to gather first” and do not present inference as author intent.
## PART B: Execution result
- **01** The card summarizes the use case; runtime output centers on “Write a tight, retention-focused YouTube script from a topic, outline, or research brief. Use when the user asks for a video script, wants to turn notes or research into a YouTube video, needs a hook/intro rewritten, or wants to plan a video end-to-end with pacing, visual beats, and CTAs.”.
- **02** When the source has headings, the agent prioritizes “When to use / When NOT to use / Inputs to gather first” so the result follows the author’s structure.
- **03** Typical output includes task judgment, concrete steps, required commands or file edits, validation, and follow-up options.
- **04** Risk context follows the fingerprint: read files, write/modify files; mostly runs locally; usually needs no extra API key.
## Running Rules
- read files, write/modify files; mostly runs locally; usually needs no extra API key.
- Validate with a small sample before expanding scope.
- Return the result, validation criteria, and next iteration options. Choose the trigger
The source does not require a stable slash command. After installation, invoke the skill by name and describe the task.
Provide inputs and boundaries
Name target files or source material, expected output, forbidden changes, and whether network or shell access is allowed. Permission fingerprint: read files, write/modify files.
Validate with a small run
Start with a small task and check whether the result follows “When to use / When NOT to use / Inputs to gather first”. Inspect diffs, logs, previews, or tests before expanding scope.
Review before delivery
Confirm the final output includes a concrete result, evidence, and next action. If it stays generic, tighten inputs, boundaries, and acceptance criteria.
---
name: youtube-script-writer
description: Write a tight, retention-focused YouTube script from a topic, outline, or research brief. Use wh…
category: productivity
source: raroque/boop-agent
---
# youtube-script-writer
## When to use
- Write a tight, retention-focused YouTube script from a topic, outline, or research brief. Use when the user asks for a…
- Use it when the task has clear inputs, repeatable steps, and validation criteria.
## What to provide
- Target material, scope, expected result, and forbidden changes.
- Whether network, commands, file writes, or external services are allowed.
## Execution rules
- Organize steps around “When to use / When NOT to use / Inputs to gather first” and keep inference separate from source facts.
- read files, write/modify files; mostly runs locally; usually needs no extra API key.
- Validate with a small sample before expanding the task.
## Output requirements
- Return the deliverable, key evidence, validation method, and next action.
- Mark missing information as unknown; do not invent commands, platforms, or dependencies. Evidence boundary and execution chain
The author source anchors workflow facts; repository files anchor sources and commands; Fluxly only adds fit, limitations, and quality judgment.
skill "youtube-script-writer" {
input -> user goal + target files + boundaries + acceptance criteria
context -> When to use / When NOT to use / Inputs to gather first
rules -> SKILL.md triggers / order / output contract
runtime -> no special runtime | read files, write/modify files | mostly runs locally
guardrails -> usually needs no extra API key + small-sample validation + diff/log review
output -> copyable result + checklist + next iteration
}YouTube Script Writer
Turn a topic, outline, or research dump into a YouTube script that holds attention from second 0 through the CTA.
When to use
- "Write a YouTube script about X"
- "Turn this research into a video"
- "Draft an intro / hook for a video on Y"
- "Plan out a 5-minute video about Z"
When NOT to use
- Long-form blog posts or articles (different pacing rules — don't force them into this template)
- Podcast outlines (conversational, not scripted)
- Shorts under 60s (different structure — lead with the payoff, no setup)
Inputs to gather first
Before writing, confirm (ask if missing):
- Topic / angle — what is the one idea the viewer walks away with?
- Target length — under 3 min, 3–8 min, or 10+ min? Pacing changes.
- Audience — beginners, experts, or mixed? Sets vocabulary floor.
- Research or source material — any facts, stats, quotes, URLs to include?
- Tone — casual/educational, docu-style, chaotic/entertainment?
If the user didn't supply research and the topic needs facts, use WebSearch / WebFetch BEFORE writing. Never invent stats or quotes.
Script structure (standard 5–8 min video)
Write the script in these labeled sections. Don't skip any.
1. Hook — first 5 seconds
- One sentence that promises a payoff or opens a loop.
- No "hey guys welcome back." No throat-clearing.
- Patterns that work:
- Curiosity gap — "Everyone gets X wrong. Here's what actually works."
- Bold claim — "You can do X in 10 minutes. I'll prove it."
- Pattern interrupt — visual or verbal surprise.
- End with an implicit "keep watching to find out."
2. Setup — seconds 5–20
- Context: why does this matter NOW, for THIS viewer?
- Credibility beat (one sentence max): who you are / why listen.
- Restate the promise in sharper form. No long preamble.
3. Body — main content
- Break into 2–4 clearly-labeled sections/chapters.
- Retention rule: every 30–45 seconds, re-hook. Tease what's coming ("but here's the twist…"), change visual pattern, or drop a memorable line.
- One idea per section. Don't stack.
- Concrete > abstract. Examples, numbers, screenshots, demos.
- If you have research: cite specifically (brand, study, date). No vague "studies show."
4. Payoff — deliver on the hook
- Close the loop opened in the hook.
- Summarize the one takeaway in one sentence. Viewer should be able to repeat it.
5. CTA — final 15 seconds
- ONE ask. Not three. Pick: subscribe, comment prompt, link in description, or watch-next video.
- Make it natural, tied to the content. "If this saved you X, subscribe" beats "smash that like button."
- End on a strong visual beat, not a fade.
Format the output
Deliver the script as:
TITLE: <working title, clickable but honest>
THUMBNAIL IDEA: <1 sentence, what's on screen>
---
[0:00] HOOK
<exact words to say>
[0:05] SETUP
<exact words>
[0:20] SECTION 1 — <name>
<exact words>
[VISUAL: brief note on B-roll / cut / graphic]
[...continue...]
[X:XX] CTA
<exact words>Rules for the script body:
- Write the spoken words, not stage directions, as the main text.
- Put visual/cut notes in
[VISUAL: …]tags inline, indented under the spoken line they belong to. - Use short sentences. Read it aloud in your head — if a sentence is hard to say, rewrite it.
- Contractions always (don't → that's how people talk).
- No jargon without a one-line definition.
After the script
Close with:
- Estimated runtime — rough estimate based on ~150 wpm spoken pace.
- Open questions — anything you had to guess at (e.g. target audience assumed to be X; pick a different tone if wrong).
- Variants to consider — one alt hook and one alt CTA, one line each. Gives the user pivot options.
Retention checklist (self-review before delivering)
- Hook is under 10 seconds and makes a clear promise
- Setup ends in under 30 seconds total
- A re-hook or pattern break every 30–45 seconds of body
- Every claim has a source or is clearly framed as opinion
- Exactly one CTA
- Body reads aloud cleanly — no tongue-twisters, no buried verbs
- Sources section follows (if WebSearch/WebFetch was used)
Decide Fit First
Design Intent
How To Use It
Boundaries And Review