How to Audit a YouTube Script in Claude Before You Record

Four checks, run in order, audit a YouTube script in Claude before recording. Score the opening with audit_hook, audit the whole draft with audit_script, run policy_preflight and check_authenticity on the same text, then fix the highest-priority passage and re-score the opening. Every check reads text only, and none of them predicts performance.

The loop assumes the draft exists as text and that the Prepublish MCP server is connected, which is documented on the MCP server page. If you want the five manual tests first, the pre-recording check runs them without any tooling. What follows is the second opinion: an agent that calls published checks and reports named fields instead of an impression.

Each step below is a prompt you paste into the conversation. Replace the bracketed parts and keep the constraint lines, which are the difference between a report and a rewrite you did not ask for.

Step 1: score the opening before you touch anything else

The opening is the cheapest text to change and the only text the hook check reads. The tool accepts between 80 and 1,500 characters, which is the first 15 to 90 seconds of speech depending on your pace.

Score the opening of my script, then diagnose it. Do not rewrite anything.

Call audit_hook with hook_text set to the opening below and niche set to [your niche].

Report in this order:
1. overall_score, grade, and one_sentence_verdict.
2. A table of every sentence with attention_pull, curiosity_gap, payoff_distance and note.
3. top_issues, with the headline, the quote and the why for each.
4. The rewrites it returned, labelled with their style.

Rules: do not rewrite any passage yourself. The only rewrites you may show are the ones the tool returned. Do not offer to rewrite the script. If a field is empty, say the field is empty.

Opening:
[paste the first 30 seconds of the draft here]

The same check runs in the browser at the hook analyzer if you would rather paste it there. The structural question the score is measuring, and the window it sits in, is covered in the first 30 seconds guide.

Step 2: audit the whole draft

audit_script takes the planned title, the full script, and an email address, because a free full audit is released by mail. It polls for 90 seconds inside the call. If the audit has not settled by then, the tool returns an id and tells the assistant to collect it with get_audit, which costs nothing and starts no new analysis.

Audit this script with audit_script. The title I plan to publish under is "[your title]". Send the result to [your email].

When it returns, report:
1. overall_score, hook_score, structure_score, pacing_score and ready_to_record.
2. one_key_improvement, quoted exactly.
3. Every entry in improvements, as a table with priority, timestamp, problem_type, retention_impact and title.
4. The retention_curve and the value of retention_curve_source.
5. Only then, the original_quote and the improved rewrite for the first improvement.

Rules: do not rewrite any passage. Do not turn the improvement list into general advice. If an improvement has an empty improved field, say that it is locked rather than filling the gap.

Step 3: run the two risk checks

Policy risk and reused-content risk are separate questions from attention risk, and they have their own tools. policy_preflight needs at least 200 characters. Both checks return category ids you can look up.

Run two checks on the draft below and keep the results separate. Do not merge them into one verdict.

1. policy_preflight with the script and the title "[your title]". Give me the verdict, total_flags, counts_by_category, and for every category that fired, its id, its label and its source_url.
2. check_authenticity with the same title and script. Give me the score, the risk_level, and each signal that fired with its name, severity and quote.

Rules: quote what the checks returned. Where a flag comes back locked, report that the passage is withheld rather than guessing what it says.

Script:
[paste the full draft]

The browser version of the policy check is the monetization checker.

Step 4: fix in priority order, then re-score only the opening

Rewrite the passage the audit ranked first, then run the hook check again on the new opening. One change at a time, so the second score is about the change you made.

Here is the revised opening. Re-run audit_hook on it and only on it.

Show the two runs side by side: overall_score, grade, and the attention_pull of each sentence in both. Tell me which sentences moved and which did not.

Rules: do not start a second audit_script call. Do not rewrite anything. If the score barely moved, say so in one sentence and stop.

Scores are generated rather than measured, so do not read a two-point move as a result. A five-point shift is worth a look. A one-point shift is noise the model produces between runs.

The checks take a fixed set of fields and nothing else. audit_script accepts video_title, script_text, and optional email, video_duration_seconds, category and audience. Everything a creator knows and cannot fit into those fields is invisible to it.

A chat model reading the same script in the conversation can see the rest of it. You can tell it why you chose the topic, what your last ten videos did, and how you sound on the third take of a section you are bored of. None of that survives a tool call, and some of it is the most useful context you have.

The honest division of labour is that the chat model judges, and the checks report. Ask the model whether the premise deserves a video. Ask the checks whether the draft delivers on the promise in the title.

A model asked to review a script will produce a review. It invents a scale, cites policy from memory, and gives you no way to compare this answer with the one it gave last week. The checks constrain that.

The last row is the point. The audit is model output too, and its own payload says so: retention_curve_source reads model when the timeline came straight from the AI response and interpolated when the backend generated or extended it (prepublish-be/internal/domain/entity/analysis.go). The gain is not accuracy against some ground truth. The gain is that the instrument has named parts, so a second run and a third party can check what it read.

The example script is not a draft. It is the caption track of But what is a neural network? by 3Blue1Brown, video id aircAruvnKk, captured on 19 September 2026. Using a published script means the checks can be read against a video whose result is already known.

The capture produced 46,010 bytes of JSON3 across 286 caption events, which is 3,357 words and 18,430 characters. The player reported a duration of 1,119.96 seconds.

Where the text came from matters, because the obvious method returns nothing. A direct fetch of the caption URL listed in the page's own data returns HTTP 200 with a zero-length body, and the same fetch under a HeadlessChrome user agent also returns a zero-length body. The request the player itself makes carries &potc=1&pot=<token>&key=yt8&lang=en&fmt=json3, and refetching that URL returned the 46,010 bytes (both measured 18 September 2026; prepublish-extension/src/content/youtube-main.js and prepublish-be/internal/infrastructure/youtube/channel_dlp.go). An audit run on an empty string is a wasted call.

script_runtime: 3,357 words

{
  "speaking_rates_words_per_minute": { "fast": 201, "median": 181, "slow": 160 },
  "source": "Prepublish study of 349 videos; see https://prepublish.ai/blog/youtube-script-length-word-count",
  "word_count": 3357,
  "runtime_minutes": { "fast": 16.7, "median": 18.5, "slow": 21 }
}

The median estimate lands within ten seconds of the real runtime, which is the only number in this workflow that can be checked against something that is not model output. It is still speaking time only.

audit_hook: the first 92 words

{
  "overall_score": 75,
  "grade": "B",
  "model_used": "pro",
  "one_sentence_verdict": "The opening establishes a clear visual premise and a relatable cognitive puzzle, though it slows down by instructing the audience on how to feel rather than advancing the mystery."
}

The per-sentence table is where the check earns its place. Every value below came back from the run.

The lowest-scoring sentence became the top issue, headlined "Instructional filler", with this reasoning: "Instructing the viewer to appreciate something interrupts the momentum of the visual puzzle. The script could pull harder by letting the visuals demonstrate the complexity naturally."

One of the three rewrites offered was a curiosity_gap version: "How does your brain know this is a 3? It is sloppily written and rendered at a low resolution of 28x28 pixels. Every time you look at a different version, completely different light-sensitive cells fire in your eye. Yet you never fail to recognize the pattern."

That is a usable diagnosis: one sentence, one reason, three alternatives. The original sentence works on screen because the visuals carry the appreciation. The check read text only.

audit_script: the full draft

{
  "notice": "This is a text-only check of an unrecorded script. It maps relative attention risk inside the draft. It does not measure or predict published YouTube retention, and it cannot account for delivery, editing, thumbnail, topic or distribution.",
  "analysis_id": "4d8206ce-9f60-46cc-b537-2a0af8b113c7",
  "analysis": {
    "overall_score": 83,
    "hook_score": 88,
    "structure_score": 84,
    "pacing_score": 78,
    "ready_to_record": false,
    "processing_time_ms": 8922,
    "retention_curve_source": "model",
    "locked": true,
    "lock_reason": "signup_required",
    "tier": "anonymous"
  },
  "open_in_browser": "https://prepublish.ai/analysis/4d8206ce-9f60-46cc-b537-2a0af8b113c7"
}

Trimmed to the fields quoted here. The one key improvement it named was this: "Dense outro housekeeping and abrupt interview appendix dissipate core lesson tension."

The improvement list arrived in this order.

Only the first entry came back complete. The other five carried locked: true, with their quote and rewrite removed server-side. That is the free-tier rule: index 0 comes back in full, because a preview a reader can dismiss as a token fix proves nothing (prepublish-be/internal/application/dto/analysis_dto.go, freePreviewImprovementIndex = 0). Read the priority column rather than the row order. In this run a HIGH entry sat first and a CRITICAL entry sat sixth.

The one fix returned complete showed the shape of the output. The flagged passage was the two-video framing at the two-minute mark. The tool quoted it in full and offered this rewrite: "There has been an explosion of modern variants recently, but you and I are going to start with the plain vanilla form. It is the foundation for all of them, and it still holds plenty of complexity for us to explore."

The attention timeline is the part most likely to be misread.

Every number in that table is model output. retention_curve_source reads model, which means the timeline came straight from the AI response rather than from any viewer. Use it as a reading of the script's shape and nothing more.

One result deserves a plain statement: this script scored 83 and returned ready_to_record: false. The rule is mechanical. The server requires an overall score of at least 75, and no improvement rated CRITICAL or HIGH (prior_audit_resolver.go, readyToRecordMinScore = 75). A CRITICAL passage in the closing kept the second condition from being met. A high score with a failing flag is not a contradiction in the tool. It is two conditions, and one of them failed.

check_authenticity: reused-content risk

{
  "score": 5,
  "risk_level": "low",
  "verdict": "The script is a highly original, educational explainer on neural networks with specific mathematical breakdowns and expert commentary, presenting negligible risk of policy violations.",
  "signals": [
    { "name": "lexical_diversity", "severity": "low" },
    { "name": "first_person_ratio", "severity": "low" }
  ]
}

Two signals fired and both came back low. The signal names are the useful part, because they are the same names every run. A script that reads as templated fires them at a higher severity, and the quote attached to each signal shows the repetition rather than asserting it.

policy_preflight: no matches, then four

Run on the same script, the policy check returned verdict: "no_matches", total_flags: 0, locked: true, and a rubric stamped rubric_version: 3 and rubric_published_at: "2026-08-15T00:00:00Z".

A check that returns nothing is easy to distrust, so I ran it a second time on a paragraph written to trip it, about replacing prescribed medication with a supplement stack and doubling the dose on camera. That run returned:

{
  "verdict": "high_matches",
  "counts_by_category": { "harmful_or_dangerous_acts": 2, "unverified_medical_claims": 2 },
  "total_flags": 4,
  "locked": true,
  "rubric_version": 3
}

Each category carries the citation for its own rule. Medical claims stated as certain point at YouTube's medical misinformation policy, and harmful or dangerous acts point at the advertiser-friendly guidelines. The flagged passages themselves came back locked, which is the same free-tier split as the improvements: the free result tells you which category matched, and the paid result tells you where.

The failure mode is specific. An agent asked to audit a script will finish the audit and then offer to fix the whole thing, and the offer arrives as a finished draft that replaces yours. The line that prevents it is a constraint, not a request.

Put this at the top of any audit prompt:

Diagnose only. Do not rewrite a passage I did not ask you to rewrite. Do not offer to rewrite the script. If a field comes back locked or empty, say so instead of filling the gap.

The last sentence is doing real work. In the run above, five of six improvements arrived with their quote and rewrite removed. An agent that wants to be helpful will invent replacements for the missing five, and the invented ones are indistinguishable from the returned one in a chat window.

Two more prompts that hold up.

The calibration prompt. Use it to test whether the checks agree with your own read before you trust them on a draft you care about.

Take the transcript below, which is the spoken script of a published video I have already watched. Call audit_hook on its first 90 seconds, then audit_script with the video's own title. Send the result to [your email].

Then give me two lists. First, everything the checks flagged. Second, anything you noticed in the transcript that the checks did not flag.

Rules: do not write a new script. Do not fix anything in this transcript. This is a calibration sample, not a draft.

The second list is the useful one, because it shows you where the checks are blind, on text whose result you already know.

The separation prompt, for the case where the agent produces a review that looks like a tool report:

Before you answer, list the tool calls you actually made and the tool names you used. If you are about to describe a check you did not call, label the rest of your answer as your own reading of the text rather than a check result.

A chat model is fluent enough to write something that reads like a hook score. Asking it to name the calls it made is the cheapest way to see the difference.

They do not see delivery, editing, thumbnail or audience history. The payload says it in the same words every time: "This is a text-only check of an unrecorded script. It maps relative attention risk inside the draft. It does not measure or predict published YouTube retention, and it cannot account for delivery, editing, thumbnail, topic or distribution."

They do not measure anything about viewers. The attention timeline is model output, stamped model or interpolated in retention_curve_source. Your own Studio curve after publishing is the measurement, and comparing the two is the only way to learn whether this instrument reads your work in a way you can act on.

They do not decide monetization. policy_preflight reports matches against published policy text and states its own scope: "This reads your script text only. Visuals, thumbnails, delivery, and edits are not checked. It flags passages that match categories in YouTube's published guidelines. It is not a YouTube decision, and it is not a guarantee."

They do not return everything on the free tier. The per-section analysis came back as zero scores and empty lists, with locked: true and lock_reason: "signup_required", and so did the title rewrite and the channel comparison.

They run against quotas. The MCP endpoint allows 100 AI-backed calls per UTC day and 6 per caller per 10 minutes by default (prepublish-fe/lib/mcp/limits.ts). The hook check has its own allowance behind the endpoint: one anonymous run per IP address in 24 hours, and three per day once an address is supplied (prepublish-be/internal/domain/service/hook_analysis_service.go, hookAnonQuotaPerDay = 1). The anonymous allowance was already spent when this article's example was prepared, which is why the hook run above carries an address. Plan the order of the checks around those limits: the cheap one is the check most likely to be refused.

They read a window, not a script. The hook field stops at 1,500 characters, which at the median measured rate of 181 words per minute is the first 90 seconds or so. An opening that runs long is audited up to the cutoff and no further.

They do not tell you whether the topic deserved a video. Every check here grades execution against the title you supply. If the premise is thin, a draft that delivers the promise will score well, and the score will be correct.