Start With the Viewer: Problem → Outcome
An audience-first angle is a deliberate choice about who the video is for and what change they want after watching. Before you write jokes, structure, or B-roll notes, you need a clear answer to: “What problem is the viewer trying to solve, and what result do they want?”
1) Find the viewer’s problem (the friction)
Problems are usually one of these: confusion (“I don’t get it”), inefficiency (“this takes too long”), risk (“I’m afraid I’ll mess it up”), or disappointment (“I tried and it didn’t work”). Your script should speak to that friction in plain language.
- Confusion: “I don’t know what to do first.”
- Inefficiency: “I’m wasting time on steps that don’t matter.”
- Risk: “I’m worried I’ll break something / look dumb / lose money.”
- Disappointment: “I followed advice and got poor results.”
2) Identify the desired outcome (the win)
Outcomes should be observable. If the viewer can’t tell whether they achieved it, it’s too vague. Aim for outcomes that are measurable, visual, or testable.
- Measurable: “Cut editing time from 2 hours to 45 minutes.”
- Visual: “A thumbnail that looks clean and readable on mobile.”
- Testable: “A hook that keeps people watching past 30 seconds.”
Quick method: Problem/Outcome sentence
Fill this in before you choose an angle: My viewer is struggling with [problem] and wants [outcome] without [common pain/cost].
Example: My viewer is struggling with rambling intros and wants a clear hook without sounding clickbait-y.
- Listen to the audio with the screen off.
- Earn a certificate upon completion.
- Over 5000 courses for you to explore!
Download the app
Choose an Angle Type That Earns Attention
Your topic is the “what.” Your angle is the “why this version of the topic is worth watching right now.” Angle types help you shape the same core value into a promise that feels specific and urgent.
Angle Type A: Speed
When to use: The viewer is impatient, overwhelmed, or on a deadline.
- Promise pattern: “Do X in Y minutes/steps.”
- Script implication: Remove optional context; lead with the fastest path and label extras as “if you want.”
Example: “Write a YouTube hook in 60 seconds using this 3-line template.”
Angle Type B: Simplicity
When to use: The viewer feels the topic is complicated or technical.
- Promise pattern: “The simplest way to do X (without Y).”
- Script implication: Use fewer terms, fewer steps, and show one default choice.
Example: “The simplest way to outline a video so you don’t ramble.”
Angle Type C: Mistake-fixing
When to use: The viewer is already trying and failing.
- Promise pattern: “Stop doing X; do Y instead.”
- Script implication: Diagnose symptoms early, then show the fix with a before/after.
Example: “Your intros are killing retention—here’s the fix in the first 10 seconds.”
Angle Type D: Comparison
When to use: The viewer is choosing between options.
- Promise pattern: “A vs B: which to use for [situation].”
- Script implication: Define the decision criteria, then test both against the same scenario.
Example: “Question hook vs bold claim hook: which keeps viewers longer?”
Angle Type E: Contrarian (but defensible)
When to use: Common advice is misleading or incomplete for a specific audience.
- Promise pattern: “Stop following [popular rule]—do this instead (if you’re [audience]).”
- Script implication: Clarify the context where the popular rule fails; prove your claim with a concrete example.
Example: “Don’t ‘introduce yourself’ in the first 30 seconds—earn attention first.”
Angle Type F: Beginner shortcut
When to use: The viewer is new and needs a safe starting point.
- Promise pattern: “If you’re new to X, start with this.”
- Script implication: Reduce choices, prevent common pitfalls, and give a minimum viable version.
Example: “If you’re new to scripting, use this one-sentence promise to stop overthinking.”
Step-by-step: Pick the best angle in 5 minutes
- Write the core value (what the viewer gets):
After this video, you can [do/understand] X. - List 3 viewer pains related to that value (time, confusion, fear, past failure).
- Choose 2 angle types that match those pains.
- Draft 2 promises (one per angle type) and underline the specific outcome.
- Pick the one that is most testable: the viewer can verify it by the end.
Write a Tight Promise Statement (Without Over-Claiming)
A promise statement is the clearest, most honest version of what the video will deliver. It’s not hype; it’s a contract. Strong promises are specific, bounded, and immediately relevant.
Promise formula (reliable and non-clickbait)
Use this structure: In this video, you’ll learn [action/outcome] so you can [benefit], using [method/constraint].
Example: In this video, you’ll learn to write a one-sentence video promise so you can hook the right viewers, using a 3-part template and real examples.
Boundaries that prevent over-claiming
Over-claiming happens when you promise results you can’t guarantee (especially performance metrics). Instead, promise what you can control: process, decisions, clarity, and deliverables.
| Over-claim | Safer, clearer promise |
|---|---|
| “This will double your views.” | “This will help you write a clearer hook that reduces early drop-off.” |
| “Guaranteed viral title.” | “A title framework that makes the value obvious and specific.” |
| “The only script you’ll ever need.” | “A reusable template for this type of video.” |
Step-by-step: Turn a vague idea into a tight promise
- Start vague: “How to write better YouTube scripts.”
- Add the audience: “...for beginners who ramble.”
- Add the outcome: “...so your intro is clear in 30 seconds.”
- Add the method: “...using a 3-line promise + hook pattern.”
- Add a boundary: “...without clickbait or fake urgency.”
Resulting promise: “Write a clear intro in 30 seconds using a 3-line promise + hook pattern—without clickbait.”
Checklist: Promise clarity and specificity
- Does the promise name a deliverable (template, checklist, script lines, decision rule) or a testable skill?
- Is the outcome observable by the end of the video?
- Is the audience implied or stated (beginner, busy, advanced, niche)?
- Is the scope realistic for the video length?
- Does it avoid guaranteed metrics (views, subscribers, revenue) unless you can truly substantiate?
- Does it include a constraint that builds trust (e.g., “without clickbait,” “with one example,” “using only free tools”)?
Align Title/Thumbnail Concept With the Script’s First 30 Seconds
Title and thumbnail are not decoration; they are the front door to your promise. The first 30 seconds must confirm that the viewer is in the right place and show the path to the outcome. Misalignment creates fast drop-off: the viewer clicks for one thing and hears another.
The alignment chain
Build these in order and keep them consistent:
- Title: states the promise in a compact way.
- Thumbnail concept: visualizes the tension or outcome (one idea).
- First 30 seconds: confirms the promise, defines the problem, previews the method, and starts delivering.
What the first 30 seconds must do (script beats)
- Confirm the click: Repeat the promise in fresh words.
- Call out the problem: Name the viewer’s pain accurately.
- Preview the method: “Here are the 3 parts…” or “We’ll fix it by…”
- Start the first step: Deliver value before the viewer gets impatient.
Example: One promise → title/thumbnail → first 30 seconds
Promise: “Write a one-sentence video promise that makes your intro instantly clear—without clickbait.”
Title options:
- “Steal This 1-Sentence Promise (Your Intros Will Be Clear)”
- “The 3-Part Promise That Fixes Rambling Intros”
Thumbnail concept (no text required): A split-screen of a messy page of notes vs a clean single sentence highlighted; a stopwatch icon to imply speed; a viewer retention graph shape as a subtle prop.
First 30 seconds (sample):
If your intros feel like you’re talking in circles, it’s usually because you never made a clear promise. In the next few minutes, I’ll show you a one-sentence promise template that tells viewers exactly what they’ll get—without sounding clickbait-y. It has three parts, and we’ll build yours together. First, here’s the most common promise mistake people make…Checklist: Title/thumbnail/script alignment
- Does the title communicate the same outcome as the promise statement?
- Does the thumbnail concept visualize one idea (problem or outcome), not three?
- Does the first 10 seconds clearly confirm what the viewer clicked for?
- Is the method previewed early (number of steps, framework name, or constraint)?
- Is the scope consistent (no “ultimate guide” title with a tiny tip video)?
Mini-Workshop: Rewrite One Promise for Beginner, Intermediate, Expert
Goal: keep the same core value, but adjust language, assumptions, and constraints so the right viewer feels “this is for me.”
Core value (do not change)
Write a clear one-sentence video promise that makes the intro focused and sets expectations.
Step-by-step workshop
- Write the core value in one plain sentence (above).
- Choose what changes by level: vocabulary, speed, examples, and what you assume they already know.
- Add one level-specific constraint: beginner = fewer choices; intermediate = efficiency; expert = nuance/edge cases.
- Rewrite the promise in one sentence each, keeping the same outcome.
Beginner version (reduce choices, remove jargon)
Promise: “By the end of this video, you’ll write one sentence that tells viewers exactly what your video will help them do—using a simple fill-in-the-blank template.”
- Why it fits: Emphasizes guidance and a template; assumes no prior knowledge.
Intermediate version (speed + mistake-proofing)
Promise: “You’ll learn a 3-part promise formula to stop rambling in your intro and get to the point fast—plus the two most common promise mistakes to avoid.”
- Why it fits: Adds efficiency and error correction; assumes they’ve made videos before.
Expert version (precision + positioning)
Promise: “You’ll refine your one-sentence video promise to attract the right viewer and set tighter expectations—using a positioning-focused template and a quick scope check.”
- Why it fits: Focuses on audience filtering and scope control; assumes they care about precision and fit.
Self-check: Did you keep the core value?
- All three versions still deliver: a one-sentence promise that focuses the intro and sets expectations.
- Only the framing changes: template simplicity (beginner), speed + mistakes (intermediate), positioning + scope (expert).
