Prepublish

View saved version →

---
name: faceless-channel-script-qa
description: 'Quality-check a faceless YouTube channel or AI-assisted voiceover script before it goes to text-to-speech or a narrator, using Prepublish to audit attention risk and rewrites, check reused or templated content signals that YouTube''s inauthentic-content rules target, and prepare the draft for voiceover. Use when the user runs a faceless channel, YouTube automation channel, documentary or history narration channel, top-10 or list channel, story channel, or uses ChatGPT, Claude or another AI to draft scripts, and asks "is my AI script good enough", "will YouTube flag this as reused or AI content", "make this sound less AI generated", "check my voiceover script", or "QA my faceless video script". Not for scripts the user wants written from nothing.'
---

# Faceless and AI-assisted script QA

Faceless channels live or die on the narration script: there is no face or personality on camera to carry a weak passage. AI-assisted drafts add a second risk: text that reads templated or interchangeable, which YouTube's inauthentic-content expectations target.

Read `references/tools.md`, `references/report-fields.md` and `references/claims-and-limits.md`. Use `assets/voiceover-prep-checklist.md` at the end.

## Inputs

- The narration script verbatim (as it will be read), and the planned title.
- The channel format if the user says it (history documentary, finance explainer, story, list, true crime, science).
- Email for the free audit if the user has no Prepublish account (explain first, never invent).

## Workflow

1. **Reused-content signals first**: `check_authenticity` with title and script. Present `risk_level`, `score` (higher means more risk), the signals in plain words with quotes, and the remediation items.
2. **Attention risk**: `audit_script` with title, script, and `category` when known. Present the top flagged passages and rewrites.
3. **Combine into one fix list**, ordered: high-severity authenticity signals, CRITICAL audit items, HIGH audit items, medium signals. Deduplicate where both checks flag the same passage.
4. **Add the creator's own contribution.** The most reliable fix for templated text is material only this channel has. Ask the user for one or two of: their own take or verdict on the topic, a specific example or source they found, a comparison they would make, a correction of a common myth. Work those into the flagged passages. Never invent facts, sources, quotes or personal experiences for them; use clearly marked placeholders like `[your example]` when the user has not supplied one.
5. **Voiceover prep**: once fixes are applied, go through `assets/voiceover-prep-checklist.md` (pronunciation of names and numbers, sentence length for breath, where emphasis falls). Offer `script_runtime` to confirm length.
6. Offer one re-check of the revised script (authenticity, audit, or both), mentioning the daily free audit limit.

## Rules

- Never suggest ways to disguise reused or scraped material, spin someone else's script, or evade YouTube's systems. The fix is original contribution and clear sourcing.
- Do not claim the result predicts monetisation approval, YPP acceptance, views or retention. The authenticity check reports text-level signals only and does not speak for YouTube.
- Keep the channel's established voice unless the user asks for a new one.
- Text the user will read aloud should be written for the ear: short sentences, numbers written the way they should be spoken, no parenthetical asides that do not work in audio.

Referenced files: 6 — file references are metadata, not package contents.

View saved version →

---
name: prepublish-getting-started
description: 'Explain what Prepublish can do for a YouTube creator and route the request to the right check. Use when the user asks "what can Prepublish do", "how do I use Prepublish", "what is a script audit", "help me improve my YouTube videos before recording", "what should I check before filming", or when a YouTube scripting request is broad and it is unclear which check fits. Prepublish audits YouTube scripts before recording: hook, structure and pacing scores, a relative attention-risk map, flagged passages with rewrites, hook scoring, policy pre-flight, reused-content signals and script length planning.'
---

# Getting started with Prepublish

Prepublish is a pre-production check for YouTube scripts. It reads a draft before it is recorded and shows what to fix while fixing it is still cheap: a rewrite, not a reshoot. It reads text only.

Read `references/claims-and-limits.md` before describing the product.

## What it can do (map the request to a check)

| The creator wants to | Use | Tool |
| --- | --- | --- |
| Know what is weak in a finished draft, with rewrites | youtube-script-audit | `audit_script` |
| Fix the draft and check the fixes landed | youtube-script-revision-loop | `audit_script`, `get_audit`, `audit_hook` |
| Judge or compare openings | youtube-hook-review | `audit_hook` |
| One full "ready to record?" pass | youtube-prerecord-checklist | all checks |
| Check demonetisation or guideline risk, or reused-content risk | youtube-monetization-preflight | `policy_preflight`, `check_authenticity` |
| Plan length or a word budget per section | youtube-script-length-planner | `script_runtime` |
| QA a faceless or AI-assisted narration script | faceless-channel-script-qa | `check_authenticity`, `audit_script` |
| Check a Short | youtube-shorts-script-check | `script_runtime`, `audit_hook`, `audit_script` |
| Review a script for a client, or a writer's delivery | scriptwriter-client-review | `audit_script` and others |

## How to explain it in two sentences

"Prepublish reads your script before you record and marks the passages most likely to lose a viewer, with a rewrite for each and a map of where the draft sags. It checks text only, so it cannot see your delivery, edit or thumbnail, and it does not predict views."

## What it does not do

- Write a script from nothing (you can draft one with the user, then audit the draft).
- Analyse a published video's analytics, retention graph or views.
- Predict views, retention, click-through rate or monetisation.
- Review thumbnails, titles for click appeal, audio or video.

When a request falls here, say so briefly and offer the nearest check that fits.

## Getting the most from it

- Paste the full script and the planned title. The audit checks whether the script delivers the title's promise.
- Users without a Prepublish account get free checks with daily limits; the full audit's free result is released by email, so they will be asked for an address (used to send the result link and a few follow-up emails with an unsubscribe link).
- Fix the top one to three passages, then re-check. Do not chase every small item.

Referenced files: 3 — file references are metadata, not package contents.

View saved version →

---
name: scriptwriter-client-review
description: 'Help a freelance YouTube scriptwriter, ghostwriter, editor or small scriptwriting agency quality-check a script before delivering it to a client channel, using Prepublish''s audit, hook and pre-flight tools, then produce a client-ready review note that explains what was checked, what was changed and what remains. Use when the user says they write scripts for a client or channel owner, asks "check this script before I send it to my client", "give me feedback my client will understand", "prepare a script review for a YouTube channel", "QA a ghostwritten script", or needs a second reader for a deliverable. Also use for channel owners reviewing a script a writer delivered to them.'
---

# Client-ready script review

For writers who deliver scripts to someone else's channel, and for channel owners reviewing a writer's draft. The goal is a defensible, neutral second read: specific passages, specific fixes, and an honest statement of what the check covers.

Read `references/tools.md`, `references/report-fields.md` and `references/claims-and-limits.md`. Use `assets/client-review-note.md` for the deliverable.

## Inputs

- The script, verbatim, and the working title the client approved.
- The client's brief if the user has it: target runtime, audience, tone, must-include points. Use only what the user shares.
- Who reads the note: the writer only (internal QA), or the client (external note). Default to internal until the user says otherwise.
- Email for the free audit if the user has no Prepublish account (explain first, never invent).

## Workflow

1. Run `audit_script` with title, script and, when known, `video_duration_seconds`, `category` and `audience` from the brief.
2. If the brief has a target runtime, run `script_runtime` on the script and compare.
3. If the topic is sensitive, run `policy_preflight`. If the channel is faceless or formula-driven, run `check_authenticity`.
4. For internal QA: present the flagged passages with rewrites, prioritised, and offer the `youtube-script-revision-loop` so the writer fixes the draft before delivery.
5. For a client note: fill `assets/client-review-note.md`. Keep it factual, short and neutral. It should help the client trust the draft, not sell a tool.

## Rules for client-facing text

- Describe the check accurately: "a text-level review of the script's hook, structure and pacing, plus a check against YouTube's published policy categories". Never claim it predicts retention or views, and never promise results.
- Do not include internal notes, the writer's private comments, or scores the user asked to leave out.
- Credit rewrites honestly: rewrites from the writer, from Prepublish, or suggested by you are all fine to use, but do not misattribute them.
- If the client's brief conflicts with a flagged issue (for example a required long sponsor read at the start), note the trade-off neutrally and let the client decide.
- Never share the client's script with anyone or anything beyond the checks the user asked for.

## Batch reviews

When a writer has several scripts for the same client, review them one at a time in the order the user gives, and keep a one-line summary per script. Mention the daily free audit limit (3 for users without an account) before starting a batch larger than that.

Referenced files: 6 — file references are metadata, not package contents.

View saved version →

---
name: youtube-hook-review
description: 'Score and improve the opening of a YouTube video with Prepublish''s audit_hook tool, sentence by sentence, then compare hook variants and pick the strongest. Use when the user shares an intro, hook, cold open, first 15 to 30 seconds, or first paragraph of a YouTube or Shorts script and asks "is this hook good", "rate my intro", "make my opening stronger", "how do I stop people clicking away in the first 30 seconds", "which of these hooks is better", or wants hook rewrites. Also use when the user wants a fast check of the opening before auditing the whole draft. Do not use for a full script (use the full audit) or for writing a brand new hook with no draft.'
---

# Review a YouTube hook

The opening is where a draft most often loses a viewer who has not yet decided to stay. This skill scores the opening lines with `audit_hook` and turns the result into a short, practical decision.

Read `references/tools.md` for the tool's exact inputs and outputs, `references/research-notes.md` before giving general hook advice, and `references/claims-and-limits.md` before describing what a score means.

## Inputs

- **The hook text, verbatim**: 10 to 5,000 characters. Best is the first 15 to 30 seconds of speech, which is roughly 40 to 90 words. If the user pasted a whole script, take only the opening lines up to the first section change, tell them which lines you are scoring, and offer a full audit afterwards.
- **Niche**: only if the user said it (for example "personal finance", "true crime", "coding tutorials").
- **Email**: only if the tool says the free anonymous hook check for the day is used. Explain first that Prepublish stores the address and may send a few follow-up emails with an unsubscribe link. Never invent one.

## Workflow: one hook

1. Call `audit_hook` with `hook_text` and, if given, `niche`.
2. Present:
   - `overall_score`, `grade` and the `one_sentence_verdict`.
   - A compact sentence table: each quote with its attention pull (0 to 10), curiosity gap (0 to 10) and payoff distance (near, mid or far), plus the `note` for the weakest sentence.
   - The `top_issues`, each with the quoted line and the `why`.
   - The `rewrites`, each labelled with its `style` and `why_works`. Keep them verbatim.
3. Recommend one rewrite, or a merge of two, and say which line of the original it fixes. If you merge or edit, label the result as your version.
4. Offer: "Want me to re-score your revised opening?" If yes, score the revised text once. Report the change honestly; a higher score is a better read of the text, not a promise of better performance.

## Workflow: compare several hooks

When the user has two to four candidate openings:

1. Score each with `audit_hook` separately (one call per variant; do not combine them into one text).
2. Show a comparison table: variant, score, grade, verdict, main issue.
3. Pick a winner and explain the deciding difference in one or two sentences, using the tool's notes.
4. If scores are within a few points, say they read about the same and let the user choose on voice and fit with the title and thumbnail.

Do not score more than four variants in one go; free checks are limited per day.

## Honest hook guidance

Use `references/research-notes.md`. In short:

- Prepublish's own studies found that speaking faster and reaching the point a few words sooner did not separate hits from flops. Do not tell users to talk faster.
- A concrete reason to keep watching, and delivering what the title promises, are better levers to discuss.
- Openings that begin with a greeting leaned toward flops in both studies; mention it as a pattern worth testing, not a rule.
- For small channels, topic and packaging usually matter more than the hook. Say so if the user is diagnosing a flop.

## Output format (no inline card for this tool)

```
Hook score: 58 (C). Verdict: <one_sentence_verdict>

| Line | Pull | Gap | Payoff | Note |
| "<quote>" | 6/10 | 3/10 | far | <note> |

Top issue: "<quote>": <why>

Rewrites:
A. (<style>) "<hook>": <why_works>
B. (<style>) "<hook>": <why_works>

My pick: B, because it fixes "<original line>" by <reason>.
This scores the text of the opening only; delivery, pacing of the edit and the thumbnail are outside what it reads.
```

Referenced files: 5 — file references are metadata, not package contents.

View saved version →

---
name: youtube-monetization-preflight
description: 'Pre-flight a YouTube script against YouTube''s published advertiser-friendly guidelines and Community Guidelines categories with Prepublish''s policy_preflight tool, and check it for reused, templated or mass-produced content signals with check_authenticity. Use when the user asks "will this get demonetized", "is this advertiser friendly", "yellow dollar sign", "limited ads", "is my script safe to monetize", "does this break community guidelines", "is this reused content", "inauthentic content", "will YouTube flag my AI script", or is writing about sensitive topics such as violence, tragedies, drugs, firearms, medical or financial claims, profanity or controversial issues. Reports category matches with YouTube''s own policy links; it is never a YouTube decision or a guarantee.'
---

# Monetisation and reused-content pre-flight

Two text-level checks that help a creator catch risky wording before recording:

- `policy_preflight`: which categories of YouTube's published guidelines the script's wording matches, with the official source link for each category.
- `check_authenticity`: signals that a script reads as reused, templated or mass-produced, with quoted evidence and fixes.

Read `references/tools.md`, `references/policy-categories.md` and `references/claims-and-limits.md` first.

## Choose the check

| The user is worried about | Run |
| --- | --- |
| Demonetisation, limited ads, advertiser-friendliness, a sensitive topic, strikes | `policy_preflight` |
| Reused content, "inauthentic content", AI-sounding or templated scripts, a faceless or automation channel repeating a formula | `check_authenticity` |
| "Is this safe to publish" in general, or both concerns | both, policy first |

## Inputs

- The script verbatim. `policy_preflight` needs at least 200 characters; if the text is shorter, say so and ask for the full script.
- The planned title. Optional for `policy_preflight` (titles are checked too, so include it when known), required for `check_authenticity`.

## Workflow

1. Run the chosen check or checks with the user's exact text.
2. For `policy_preflight`, present:
   - The verdict in plain words: `no_matches` = no wording matched a category; `review_suggested` = some lines match categories and deserve a second look; `high_matches` = several strong matches.
   - Counts by category, grouped by family. Community Guidelines matches come first, because those policies are enforced through removal and strikes, not only ad limits. Advertiser-friendly matches affect whether and how ads run.
   - For each category with a match, the official YouTube page from the rubric (see `references/policy-categories.md`).
   - Quoted passages and suggested rewording when included. If `locked` is true, the counts are real but the quotes are not part of the free check: say that a locked result is not a clean pass, and give the full report link if one was returned.
   - The `scope_statement`.
3. For `check_authenticity`, present:
   - `score` (0 to 100, higher means more risk) and `risk_level` (low, medium, high) with the `verdict`.
   - Each signal in plain words with its severity and the quoted line. Translate signal names (for example `template_story_narration` becomes "narration follows a stock story template").
   - The `remediation` items: current passage, fix, why.
4. Offer next steps: reword the flagged lines together (then re-check once), add first-hand material the channel owns (their own examples, opinions, data, footage notes), or run the full `youtube-script-audit`.

## How to talk about risk

- This reads the script text only. It cannot see visuals, thumbnails, audio, delivery, the edit, or the channel's history, and YouTube reviews all of those.
- Never say a video "will" or "will not" be demonetised, limited, removed or struck. Say which published categories the wording matches and link the policy page.
- A sensitive topic is not forbidden. Many categories allow the topic when it is handled in a documentary, educational or news framing without gratuitous detail. Point the user to the official page for the exact wording.
- Medical and financial claims stated as certain are matched against Community Guidelines pages. Suggest softening certainty and citing sources rather than removing the topic.
- For reused-content risk, the fix is almost always more of the creator's own contribution: original commentary, their own examples, a clear point of view. Do not suggest ways to disguise reused material.

## Output shape

```
Policy pre-flight: review suggested (3 matches).
Community Guidelines: none.
Advertiser-friendly: Controversial issues (3). Policy: https://support.google.com/youtube/answer/6162278#Controversial_issues
  "<quoted line>" -> suggested: "<rewording>"
Reused-content check: risk 28/100 (low). Signals: <plain-language list>.
Scope: text only; not a YouTube decision and not a guarantee.
```

Referenced files: 5 — file references are metadata, not package contents.

View saved version →

---
name: youtube-prerecord-checklist
description: 'Run a complete "ready to record?" check on a YouTube script with Prepublish in one pass: spoken runtime against the target length, the opening hook, the full script audit with rewrites, the policy pre-flight and the reused-content check, then give a clear go or fix-first verdict with a short checklist. Use when the user says "is my script ready to record", "final check before filming", "pre-publish checklist", "pre-production review", "check everything before I shoot", "QA my script", or wants one consolidated review instead of separate checks. Do not use for a single narrow question (use the specific skill) or for published videos.'
---

# Ready-to-record check

One consolidated pass over a finished draft, in the order that avoids wasted work: length first (a script that is twice too long changes everything), then the full audit, then the opening, then the risk checks.

Read `references/tools.md`, `references/report-fields.md` and `references/claims-and-limits.md`. Use `assets/prerecord-checklist.md` for the final output.

## Inputs

- The full script, verbatim, and the planned title (both required).
- The target runtime, if the user has one. Ask once; if they have none, skip the length comparison.
- Email for the free audit if the user has no Prepublish account (explain its use first, never invent one).
- Whether the topic is sensitive or the channel reuses a format (faceless, compilation, AI-assisted narration). If unknown, run both risk checks.

## Order of checks

1. **Length**: `script_runtime` with `script_text`. Compare to the target. If the draft is more than 25 percent over or under the target, tell the user now and ask whether to continue or adjust first.
2. **Full audit**: `audit_script` with title, script and target runtime in seconds if given. Handle `running` with `get_audit`.
3. **Opening**: the audit already scores the hook. Call `audit_hook` on the opening only if the audit's hook score is under 50 or the top flagged passage is in the opening, so the user gets hook rewrites.
4. **Policy**: `policy_preflight` with script and title.
5. **Reused content**: `check_authenticity`, when the channel is faceless, AI-assisted, a compilation or list format, or the user asked. Otherwise skip and say so.

Stop early and report if a tool reports an allowance limit. Do not repeat checks already done in this conversation for the same draft; reuse their results.

## Verdict

- **Ready to record**: `ready_to_record` is true or no CRITICAL items remain, no Community Guidelines policy matches, reused-content risk is low or not checked, length within 25 percent of target.
- **Fix first**: anything else. List the fixes in priority order: CRITICAL audit items, Community Guidelines matches, HIGH audit items, high reused-content risk, advertiser-friendly matches the user cares about, length.

The verdict describes the script text only. Say that recording, editing, thumbnail and title packaging are outside the check.

## Output

Fill `assets/prerecord-checklist.md`. Keep it to one screen. Offer to start the `youtube-script-revision-loop` on the fix list.

Referenced files: 6 — file references are metadata, not package contents.

View saved version →

---
name: youtube-script-audit
description: 'Audit a finished YouTube script before recording with Prepublish''s audit_script tool, then explain the scores, the relative attention-risk map, the flagged passages and the copy-paste rewrites. Use when the user pastes a YouTube script, voiceover script, video essay, explainer, documentary, tutorial or faceless-channel narration draft and asks for feedback, a review, a check, a critique, "is this script good", "will people stay watching", "where is it boring", "why do viewers drop off", "improve my audience retention before recording", or "check my script before I film". Do not use to write a new script from scratch, to review a published video''s analytics, or for grammar-only proofreading.'
---

# Audit a YouTube script before recording

Use this skill when a creator has a written draft and wants to know what to fix before they record. Prepublish reads the text only and returns scores, a relative attention-risk map across the draft, the passages most likely to need revision, and rewrites.

Read `references/tools.md` for exact tool inputs and errors, `references/report-fields.md` for how to read and present the result, and `references/claims-and-limits.md` before you describe what the result means.

## Inputs to collect

1. **The script, verbatim.** At least 50 characters; a real audit needs the full draft. If the user pasted only part, ask whether this is the whole script. Never rewrite, summarise, translate or tidy it before sending.
2. **The planned title.** Required. The audit checks whether the script delivers the title's promise. If the user has none, ask for a working title; if they still have none, use a short neutral description of the topic and say you did so.
3. **Email, only for users without a Prepublish account.** The free result is released by email. Before asking, explain in one sentence: Prepublish emails the result link to that address and may send a few follow-up emails about the audit, each with an unsubscribe link. Never invent an address, never guess one, never reuse one from elsewhere in the conversation without asking.
4. **Optional, only if the user said them:** intended runtime (`video_duration_seconds`), category, audience. Never assume these.

If the user shares a published video's transcript, you may audit it as text, but say plainly that Prepublish is built for drafts before recording and that a transcript cannot show delivery, editing or visuals.

## Workflow

1. Call `audit_script` with `video_title`, `script_text`, and the optional fields the user gave. Include `email` only when the tool or the user's situation requires it.
2. If the result says the email is required, ask for it as described above, then call again with the same input.
3. If the result has `status: "running"`, tell the user the audit is still processing, wait about a minute, then call `get_audit` with the `analysis_id`. Do not start a second audit.
4. When the audit is `completed`, present it (see below). When it `failed`, say so, show `error_message` if present, and offer to try once more.
5. Offer the next step: apply the top fix and re-check with the `youtube-script-revision-loop` workflow, check the opening alone with `audit_hook`, or run the pre-flight checks if the topic is sensitive.

## Presenting the result

In ChatGPT the audit renders as an inline report card. When it does, keep your message short: the overall score with its label, the `one_key_improvement`, and one sentence on where the attention-risk map dips. Do not reprint the card.

Without the card, use this shape:

```
Overall: 62/100 (Mixed). Hook 52, structure 68, pacing 60.
First fix: <one_key_improvement>

1. [CRITICAL] <title> (<location>)
   Your line: "<original_quote>"
   Rewrite: "<improved>"
   Why: <why>
2. [HIGH] <title> (<location>)
   Your line: "<original_quote>"
   <rewrite if included, otherwise: "The rewrite for this passage is not part of the free check.">

Attention-risk map: dips around <position>% (<note>), recovers at <position>% (<note>).
Full report: <open_in_browser>
Scope: this reads the script text only; it does not predict how a published video will perform.
```

Rules:

- Quote the user's lines exactly as the tool returned them.
- Show rewrites exactly as returned. If you add your own idea, label it "My suggestion".
- For locked passages, name the problem from `title` and say the rewrite is not part of the free check. Do not invent a rewrite and present it as Prepublish's, and do not say the report link contains the locked rewrites.
- Lead with CRITICAL and HIGH items; mention MEDIUM and LOW only as a count unless the user asks.
- Use Prepublish's labels for scores (Needs work, Mixed, Strong). Never convert a score into a retention percentage or a view prediction.

## When not to call the tool

- The user wants a new script written: help them write it, then offer to audit the draft once it exists.
- The user wants to know why a published video underperformed: explain that Prepublish checks drafts, not analytics; suggest reviewing topic and packaging first, and offer to audit the next draft.
- The text is not a script (an email, a cover letter, a blog post not meant for video): do not call Prepublish.
- The user asks how many views or how much watch time a video will get: say Prepublish does not forecast performance and offer the audit instead.

## Examples

- "Here is my script for 'Why Airplanes Avoid the Pacific'. Can you check it before I record?" Collect email if needed, call `audit_script`, present.
- "Is this intro good?" followed by two sentences: use `youtube-hook-review` instead.
- "Audit this and send it to me@example.com" followed by a script without a title: ask for the planned title first, then audit.

Referenced files: 6 — file references are metadata, not package contents.

View saved version →

---
name: youtube-script-length-planner
description: 'Convert between YouTube script word count and spoken runtime with Prepublish''s script_runtime tool, and plan a section-by-section word budget for a target video length. Use when the user asks "how many words for a 10 minute YouTube video", "how long will this script be", "how long is 1500 words spoken", "words per minute for YouTube voiceover", "my script is too long, what should I cut", "script length for an 8 minute video", or wants an outline with word counts per section. Uses measured speaking rates from 349 YouTube videos (160, 181 and 201 words per minute). Free and instant.'
---

# Plan script length and runtime

`script_runtime` is free, local arithmetic over Prepublish's measured speaking rates: 160 words per minute (25th percentile), 181 (median) and 201 (75th percentile), measured across 349 YouTube videos. Use it instead of guessing a rate.

Read `references/tools.md` for inputs.

## Which input to send

| User has | Send |
| --- | --- |
| A pasted script | `script_text` (the tool counts the words) |
| A word count | `word_count` |
| A target runtime | `target_minutes` (decimals allowed, for example 8.5) |

Call the tool once per question. Do not count words yourself when the tool can.

## Present the answer

- Give the range, not only the median: "About 1,600 to 2,010 words for 10 minutes; 1,810 at a typical pace."
- Say which end fits the user: slower, deliberate narration (documentary, calm explainer) sits near 160; energetic commentary near 201. If the user knows their own pace, prefer it.
- Always add the caveat from the tool: pauses, B-roll, demonstrations, on-screen text and music beds make a finished edit run longer than the spoken words alone.

Note: Prepublish's own study found speaking pace did not separate hits from flops (181 versus 180 words per minute). Do not tell the user to talk faster to "improve retention"; pace is a style choice.

## Section budget (when the user wants an outline)

1. Get the target runtime and the format (explainer, documentary, list, tutorial, story, commentary).
2. Call `script_runtime` with `target_minutes` to get the word budget.
3. Split it into sections using `assets/section-budget-template.md`. A common split for a 10-minute explainer: opening 5 to 8 percent, setup 10 to 15 percent, three to five body sections sharing most of the rest, payoff and close 8 to 12 percent. Present these as a planning starting point, not a rule.
4. For a draft that is too long: compute its runtime from `script_text`, give the number of words to cut to reach the target, and suggest cutting inside the sections a Prepublish audit flagged for pacing first. Offer to run `youtube-script-audit` to find them.

## Shorts

For Shorts, use seconds: a 45-second Short at 160 to 201 words per minute is roughly 120 to 150 words. The same caveat about pauses applies.

Referenced files: 6 — file references are metadata, not package contents.

View saved version →

---
name: youtube-script-revision-loop
description: 'Revise a YouTube script with the user, then re-check it with Prepublish so each round fixes the highest-priority flagged passages first. Use when the user says "fix my script", "improve this draft", "apply the suggestions", "rewrite the weak parts", "make it more engaging", "tighten the pacing", "help me revise before I record", or wants to compare draft one and draft two of the same video. Works from an existing Prepublish audit in the conversation or starts one. Do not use to generate a script from nothing or to rewrite someone else''s script without the user''s request.'
---

# Revise and re-check a YouTube script

A good revision round changes a few high-priority passages, keeps the creator's voice, and checks that the fixes landed. This skill runs that loop with `audit_script`, `get_audit` and, for openings, `audit_hook`.

Read `references/tools.md`, `references/report-fields.md` and `references/claims-and-limits.md`. Use `assets/revision-plan-template.md` for the plan you show the user.

## Before the first round

- Make sure there is an audit of the current draft. If the conversation already has one (an `analysis_id` or a report), reuse it with `get_audit` instead of paying for a new audit. If not, run the `youtube-script-audit` workflow first.
- Ask one question if it matters and is unknown: "Should I keep your wording where possible, or rewrite freely?" Default to keeping the creator's voice.

## Each round

1. **Plan.** Take the CRITICAL and HIGH items, at most three per round. For each: location, the user's line, the problem in one sentence, and the fix. Use Prepublish's rewrite where it was included. Where the rewrite is locked or missing, write your own fix and label it "My suggestion".
2. **Confirm.** Show the plan using the template. Let the user accept, change or skip items.
3. **Apply.** Produce the revised script with only the agreed changes. Mark changes so the user can see them (for example a short list of "changed lines" after the script). Never silently change facts, names, numbers or claims in the script.
4. **Re-check.** Ask before spending another audit: "Re-audit the revised draft?" If yes, call `audit_script` with the full revised script and the same title. If only the opening changed, `audit_hook` on the new opening is a cheaper check.
5. **Compare.** Show before and after for the overall and three sub-scores, and whether the fixed passages are still flagged. Say what improved and what is still open. Present score changes as a better read of the text, never as a predicted change in views or retention.
6. **Stop** when there are no CRITICAL or HIGH items left, when `ready_to_record` is true, when the user is satisfied, or after three rounds. Do not chase small score changes; MEDIUM and LOW items are optional polish.

## Voice and fidelity rules

- Keep the creator's phrasing, jokes, catchphrases and point of view unless a flagged passage requires a change.
- Do not add facts, statistics, quotes or claims that were not in the script. If a fix needs a fact ("add a specific number"), ask the user for it or leave a clearly marked placeholder like `[your number]`.
- Keep the title's promise intact, or flag the mismatch if the script cannot deliver it.
- If the user's instruction conflicts with a Prepublish suggestion, follow the user and note the trade-off once.

## Limits

Anonymous users get 3 free full audits a day. A full loop can use two or three. Tell the user when a re-check would use their last free audit of the day, and prefer `get_audit` and `audit_hook` where they are enough.

Referenced files: 7 — file references are metadata, not package contents.

View saved version →

---
name: youtube-shorts-script-check
description: 'Check a YouTube Shorts, TikTok or Reels script before filming with Prepublish: score the first line or two as the hook, check that the spoken length fits the target duration, and audit the full short script for attention risk with rewrites. Use when the user shares a script for a Short, a vertical video, a 15, 30, 45 or 60 second video, or asks "is my Shorts hook good", "how many words for a 60 second Short", "will people swipe away", "make my Short script tighter", or "check my TikTok script". Not for long-form scripts (use the full audit) and not for predicting views, swipe rate or viewed-versus-swiped-away figures.'
---

# Check a Shorts script

A Short has seconds to earn attention and no room for setup. This skill runs the three checks that matter most, cheapest first.

Read `references/tools.md` and `references/claims-and-limits.md`.

## Inputs

- The script verbatim and the target length in seconds (ask once; default to 45 seconds if the user has no target and say so).
- A working title or topic line (needed for the full audit).
- Email for the full audit if the user has no Prepublish account (explain first, never invent).

## Workflow

1. **Length**: `script_runtime` with `script_text`. Convert the minutes to seconds. Compare with the target: at 160 to 201 words per minute, 30 seconds is about 80 to 100 words, 45 seconds about 120 to 150, 60 seconds about 160 to 200. If the script is over, say how many words to cut.
2. **Opening line**: `audit_hook` on the first one or two sentences. In a Short the opening line has to do the job a whole intro does in a long video. Present the score, the weakest line and the rewrites.
3. **Full script**: if the script is at least 50 characters, `audit_script` with the title and script. In a Short, focus on flagged passages that delay the payoff or repeat a point; mention the attention-risk map only if it shows a clear dip.
4. **Tighten**: offer one revision that applies the hook rewrite, cuts to the target length and fixes the top flagged passage. Keep the creator's voice. Offer one re-check of the hook.

## Shorts-specific guidance you may give (as craft advice, not predictions)

- Put the payoff or the promise in the first line; setup that a long video can afford usually does not fit.
- One idea per Short. If the script has two, suggest splitting it into two Shorts.
- If the Short is meant to loop, make the last line lead naturally back into the first.
- On-screen text should reinforce, not repeat, the spoken line.

Never quote viewed-versus-swiped-away rates, retention percentages or view forecasts as outcomes of these checks. The tools read text only.

Referenced files: 5 — file references are metadata, not package contents.