Video scripting used to be my bottleneck.
I'd burn 3–5 hours on every script:
- Dig up research
- Plan out structure
- Write everything
- Stick in hooks, CTAs
- Shot list
Twenty pages later, I’d be cooked before the camera even rolled.
Now? AI handles about 90% of this.
Here's what changed:
- Script finished in 10 minutes
- Tighter structure by default
- Engaging hooks (actual catchiness, not formulaic garbage)
- As soon as the script drops, I can film
95% time cut, for real.
How I Actually Automated Scripting
Idea to teleprompter-ready script, 10 minutes, every time:
import openai
from duckduckgo_search import DDGS
class AIVideoScripter:
def __init__(self):
self.client = openai.OpenAI()
self.ddgs = DDGS()
def create_complete_script(self, video_idea: str, video_type: str = "tutorial"):
print(f"📝 Creating script for: {video_idea}")
research = self.research_topic(video_idea)
titles = self.generate_titles(video_idea, research)
hooks = self.create_hooks(video_idea, video_type)
script = self.write_full_script(
topic=video_idea,
research=research,
title=titles[0],
hook=hooks[0],
video_type=video_type
)
script_with_broll = self.add_broll_notes(script)
final_script = self.format_for_teleprompter(script_with_broll)
return {
'titles': titles,
'hooks': hooks,
'full_script': final_script,
'word_count': len(final_script.split()),
'estimated_duration': self.estimate_duration(final_script)
}
def research_topic(self, topic: str):
print("🔍 Researching topic...")
results = self.ddgs.text(topic, max_results=10)
research_data = [{"title": r["title"], "snippet": r["body"], "url": r["href"]} for r in results]
prompt = f"""
Summarize this research about: {topic}
- Key facts and stats
- Current trends or tools
- Common pain points
- Best practices mentioned
Return as structured summary.
"""
response = self.client.chat.completions.create(
model="gpt-4",
messages=[{"role": "user", "content": prompt}]
)
return response.choices[0].message.content
def generate_titles(self, topic: str, research: str):
prompt = f"""
Create 5 YouTube titles for a video about: {topic}
Each title should:
- Be 60 chars or less
- Include numbers if possible
- Be SEO-friendly (include main keyword)
- Stand out in search results
Format title types:
1. How-to
2. Listicle
3. Results-focused
4. Contrarian
5. Ultimate guide
Return as JSON array.
"""
response = self.client.chat.completions.create(
model="gpt-4",
messages=[{"role": "user", "content": prompt}],
response_format={"type": "json_object"}
)
import json
result = json.loads(response.choices[0].message.content)
return result.get('titles', [])
def create_hooks(self, topic: str, video_type: str):
prompt = f"""
Create 5 hooks (first 10 seconds) for: {topic}
Each hook should:
- Grab attention in first 3 seconds
- State value prop
- Be 2-3 sentences max
Hook formulas:
1. Problem → Solution preview
2. Bold claim
3. Question → Answer preview
4. Before/After
5. Pattern interrupt
Return as JSON array with hook_text and formula_used.
"""
response = self.client.chat.completions.create(
model="gpt-4",
messages=[{"role": "user", "content": prompt}],
response_format={"type": "json_object"}
)
import json
result = json.loads(response.choices[0].message.content)
return result.get('hooks', [])
def write_full_script(self, topic: str, research: str, title: str, hook: str, video_type: str):
print("✍️ Writing full script...")
structure_templates = {
'tutorial': "Quick win in first 60 seconds. 3-5 steps. Show don't tell.",
'review': "What it is, who it's for, features breakdown, pros and cons, verdict",
'vlog': "Cold open (hook), intro, journey with ups/downs, reflection"
}
structure = structure_templates.get(video_type, structure_templates['tutorial'])
prompt = f"""
Write a complete video script:
TITLE: {title}
TOPIC: {topic}
TYPE: {video_type}
HOOK: {hook}
RESEARCH: {research[0:1000]}
STRUCTURE:
{structure}
TARGET LENGTH: 8-12 minutes (tutorial) or similar
WRITING STYLE:
- Conversational and direct
- Use "you" to address viewer
- Short, punchy sentences
FORMATTING:
- Include timestamps for each section
- Mark [PAUSE] where needed
- Note [SHOW ON SCREEN: ...]
Write the complete script now.
"""
response = self.client.chat.completions.create(
model="gpt-4",
messages=[{"role": "user", "content": prompt}],
temperature=0.8
)
return response.choices[0].message.content
def add_broll_notes(self, script: str):
prompt = f"""
Review this video script and add B-roll suggestions:
{script}
For each section, suggest specific footage to show.
Format as [B-ROLL: description]
Insert inline at relevant points.
Return the full script with B-roll notes added.
"""
response = self.client.chat.completions.create(
model="gpt-4",
messages=[{"role": "user", "content": prompt}]
)
return response.choices[0].message.content
def format_for_teleprompter(self, script: str):
# Clean up and format for teleprompter
...
def estimate_duration(self, script: str):
clean_script = script.replace('[PAUSE]', '')
word_count = len(clean_script.split())
minutes = word_count / 140
return f"{int(minutes)}:{int((minutes % 1) * 60):02d}"
# Usage
scripter = AIVideoScripter()
# Generate complete script
script_data = scripter.create_complete_script(
video_idea="How to use AI to automate your content creation",
video_type="tutorial"
)
# Show results
print("\n📋 TITLE OPTIONS:")
for i, title in enumerate(script_data['titles'][0:3], 1):
print(f"{i}. {title}")
print("\n🐟 HOOK OPTIONS:")
for i, hook in enumerate(script_data['hooks'][0:3], 1):
print(f"{i}. {hook.get('hook_text', hook)}")
print(f"\n📝 FULL SCRIPT:")
print(f"Word count: {script_data['word_count']}")
print(f"Duration: ~{script_data['estimated_duration']}")
# Save to file
with open('video_script.txt', 'w') as f:
f.write(script_data['full_script'])
print("\n✅ Script saved to video_script.txt")
Video Script Templates That Don’t Suck
Tutorials
tutorial_brief = "Create tutorial script for: [TOPIC] (8-12 mins, medium-fast, helpful teacher tone)"
Reviews
review_brief = "Create review script for: [PRODUCT] (8-10 mins, honest, balanced tone)"
Vlogs & Stories
vlog_brief = "Create vlog script for: [TOPIC/EVENT] (6-10 mins, personal, authentic tone)"
Shorts
short_form_brief = "Create short video script for: [TOPIC] (30-60 sec, 75-150 words, visual-first)"
Script Checklist—What Actually Matters
Hooks:
- Hits in 3 seconds, not 30
- Real, clear value for the viewer
- Gives a reason to keep watching
Structure:
- Obvious flow
- Timestamps, not walls of text
- Natural pacing
Content:
- Tight and actionable
- Real examples, not generic
- Actual viewer problems solved
- Title promise delivered (or you’re wasting everyone’s time)
Production Notes:
- B-roll: Included, not skipped for “later”
- Overlay notes in place
- [PAUSE] marks where you’ll get out of breath
- CTAs where they work, not just “smash Like”
Readability:
- Clean for teleprompter
- Simple, spoken language
- Quick sentences—no marathon paragraphs
My Video Scripting Stack
- ChatGPT Plus ($20/mo) — main generator, GPT-4.1 API for custom stuff
- Claude Pro ($20/mo) — sometimes longer-form or “fresher” takes
- DuckDuckGo (free) — quick topic research and reference checking
- Google Docs (free+shareable) — pasting, versioning, backup
Optionals:
- PromptSmart ($15/mo) — teleprompter that doesn’t lag
- Descript ($12/mo) — edit video by editing script
Actual monthly cost: $20–47
What Changed For Me
Old way:
- Scripts took half a day
- Usually too long, messy, hard to film
- Multiple re-shoots because stuff didn’t flow
- 1–2 videos a week, max
AI way:
- 10–15 minutes for fully polished script
- Clean structure, fewer wasted takes
- 5–7 videos per week if I want
By the numbers:
- 95% time reclaimed (5 hours → 15 minutes, per script)
- Output is up 3x
- Better hooks, tighter edits
- +23% view duration (yeah, people don’t drop off as fast)
Wildest test: Scripted, filmed, and edited 3 videos in ONE day, solo. Would've needed three days with old process.
Screw-Ups I See and Made
- Reading the AI script word-for-word—nope, adapt as you film
- Too formal—if you wouldn’t say it, don’t script it
- No B-roll notes—can’t fix this in editing
- No timestamps—editing’s a nightmare
- Weak hooks—10 seconds to win them or lose them
Wrap Up
Manual scripting is dead. I use AI to cut my script time by 95%. That gives me more time to film, ride, build, ship, whatever.
Get my actual stack, prompts, and tools at axon.nepa-ai.com.