AI video has crossed the “wow, that’s real” line. The problem is everyone else has crossed it too — which means the uncanny, over-smooth, suspiciously-perfect clip is now the default, not the exception. The clips that actually stop a thumb are the ones that feel a little human: a character who hesitates, a voice that breathes, a face that says one thing while the mouth says another.

That’s not luck. It’s prompting. Here’s how to write AI video prompts that earn the second look.

The short version

To write AI video prompts that look and sound human in 2026: pick your model before you write a word, lock your characters first with a reference sheet or reference images, script dialogue in spoken rhythm (with micro-pauses, audible breaths, and the occasional “um”), layer in emotional subtext, keep every scene under ~8 seconds, and structure the whole thing as a clean, segmented prompt. The single biggest mistake is writing for the page instead of for the ear and the eye.

Now the detail.

1. Choose your model before you write the prompt

A prompt that sings on one model can flop on another, because each model was trained to “listen” differently. So this is decision zero, not an afterthought.

The current landscape worth knowing:

• Google Veo 3.1 — the cinematic heavyweight, with synchronized native audio, dialogue, and reference-image character control. Clips come in 4, 6, or 8-second lengths at 720p/1080p.
• Kling, Sora 2, Seedance, Runway Gen-4 — each has its own strengths in motion realism, fidelity, or stylization. Many ad teams now mix models in one project: fast iteration on one, hero shots on another, character scenes on a third (AdCreate describes exactly this multi-model workflow).

The practical takeaway: read the prompting guide for your model and write to its grammar. Veo, for instance, rewards a structured five-part formula — [Cinematography] + [Subject] + [Action] + [Context] + [Style & Ambiance] — per Google’s own guidance. Other models prefer one clean idea per shot (Leonardo.Ai’s guide is good on this).

2. Build your characters first — then the story

If you’re producing a series of clips and you want them to feel like one world, set your stage before you write a single scene. Out-of-place characters are the fastest way to break the illusion.

Two ways to lock consistency:

Character reference sheets. Write an exact, almost obsessively specific physical description and reuse it verbatim in every prompt. Same hair, same jacket, same glasses, same mannerisms — copied and pasted, only the action changes. Replicate’s Veo 3 guide makes the point bluntly: the more unique and specific the description, the better the model holds the character across separate generations. Dr. Wafae Bakkali’s Google Cloud guide adds a pro move — paste the unchanged description every time, and use Gemini as a scene generator to spin variations off that locked profile.

Reference images (the “Ingredients to Video” route). This is the feature the AI crowd keeps gesturing at. In Veo 3.1 / Google Flow, you generate your “ingredients” — character, object, setting — as reference images (often with Gemini 2.5 Flash Image, a.k.a. Nano Banana), then compose scenes from them so the look stays consistent across shots, as Google documents here. Vertex AI’s subject-image workflow supports up to three reference images of a single person, character, or product. Think of it as chain-prompting: because the asset already exists, the visual thread never breaks.

Set the stage, design the characters, then storyline it — by hand if you’re a good storyteller, or with AI as a co-writer if you’re not.

3. Kill the robot: make the dialogue sound human

Here’s the mindset shift most people miss: you are not writing narration. You are writing a performance. Narrative-structured, perfectly-punctuated dialogue is exactly what makes audio sound robotic — because real humans don’t talk in clean paragraphs.

The fix is to direct the delivery, not just the words. Four techniques that break the robotic pattern:

Add micro-pauses. Tell the model exactly where to hesitate. “…with a long, thoughtful pause after he says ‘okay,’” or “stuttering slightly, like he’s been caught off guard.” Most voice models read pauses through punctuation — ellipses (…) create natural hesitation, and tools like ElevenLabs and Deepgram use punctuation and filler words to control rhythm.

Define the breath. Robotic audio has no inhalation. Ask for a sharp, audible intake of breath before the line, or a soft, trailing exhale at the end of the sentence. In ElevenLabs v3 you can do this literally with audio tags like [sighs] and [exhales] (tag reference here).

Add non-lexical elements. Humans fill speech with non-words. Drop in a small genuine chuckle mid-sentence, a throat-clear at the start, a half-swallowed “um.” ElevenLabs v3 supports [laughs], [clears throat], [hesitates], and [stammers] as performance cues, per their docs — and competing models like MiniMax now model “um,” “uh,” and “ah” natively too.

Describe the texture, not the voice. Don’t write “a human voice.” Describe the physics of the sound: “slightly muffled, as if the character is speaking from behind a closed door.” You’re directing acoustics, and the model has far more to grab onto.

The throughline: when you write dialogue, write like you’re in the scene — not like you’re reading the script aloud at a meeting.

4. Add emotion through subtext

This is the advanced move, and it’s where AI video stops feeling generated.

Subtext is the gap between what a character feels and what they show. A person says “I’m so happy for you” while their face does something else entirely. We read that gap every single day — it’s the texture of being human.

So don’t just label the emotion. Build the contradiction into the prompt: the cheerful words, the tight smile, the sigh before the sentence, the hesitation that betrays the line. ElevenLabs’ emotional-context guide shows how layered tags like [tired], [resigned], or [quietly] mid-line create exactly this kind of arc. Master the description of human emotion — precisely, not vaguely — and the model will perform it.

5. Keep every scene under ~8 seconds

A hard constraint to design around: most models still generate in short bursts — Veo 3.1 tops out around 8 seconds per clip, and creators broadly treat ~8 seconds as the sweet spot (Replicate notes that dialogue should be sayable in roughly that window).

Practical consequences:

• Write dialogue that fits. Cram too many words in and the character speed-talks; too few and you get awkward silence or AI gibberish.
• Storyboard in beats. Think in 8-second chunks and stitch them, rather than imagining one long unbroken shot. Veo even lets you assign actions to timed segments ([00:00–00:02], [00:02–00:04]…) inside a single prompt — a clean way to direct multi-shot scenes (Google’s guide walks through this).

One small but mighty syntax tip from the Google Cloud community guide: to make a line spoken rather than printed as on-screen text, put a colon after the speaker’s action — The detective leans in: “We don’t have much time.” — and add (no subtitles) if your model tends to caption things.

6. Convert your prompt to JSON (the structured-prompt trick)

Here’s a technique the AI-video community swears by: take your finished prompt and restructure it as JSON before you feed it in. Generative video models tend to follow a clean, segmented blueprint more faithfully than a wall of prose, because every element gets its own labeled slot.

A JSON prompt might look like:

{

  “shot”: “slow 180° arc, shallow depth of field”,

  “subject”: “weathered fisherman, grey knit cap, salt-and-pepper beard”,

  “action”: “grips the railing, gazes at the churning sea”,

  “setting”: “fishing trawler, overcast dawn”,

  “lighting”: “soft, cool, diffused”,

  “mood”: “melancholic, contemplative”,

  “audio”: “wind, distant gulls, low ambient hum”,

  “dialogue”: “The sea, she takes what she wants. [exhales]”

}

Multiple guides document why this works: it forces clarity, enables reusability (swap one field without rewriting), and improves consistency across shots — see ImagineArt’s JSON guide and this deep-dive on why JSON beats generic prompts. You can convert a plain script to JSON by hand or with a free converter tool.

One honest caveat worth knowing (the part most JSON evangelists skip): Google’s own official Veo guidance doesn’t demand strict JSON. Its house format is structured natural-language prose built on the five-part formula, plus optional timestamped segments. So JSON is a powerful, community-proven habit — especially for repeatable, multi-scene production — but it’s a tool, not a law. Test both against your model and keep whatever wins.

Copy-paste prompt skeleton

[Camera/Shot]: medium close-up, slow push-in, shallow depth of field

[Subject]: <paste your locked character description, verbatim, every time>

[Action]: <one clear action that fits in ~8 seconds>

[Setting/Context]: <location, time of day, weather>

[Lighting & Mood]: <source, direction, softness, color, emotional tone>

[Audio]: <ambient sound + acoustic texture>

[Dialogue]: The character pauses, then — softly: “your line here.” [sighs]

(no subtitles)

The human-prompting checklist

• [ ] Chose the model and read its prompting guide first
• [ ] Locked characters with a verbatim reference sheet and/or reference images
• [ ] Wrote dialogue in spoken rhythm, not paragraph form
• [ ] Marked micro-pauses, breaths, and at least one non-lexical filler
• [ ] Described sound texture, not just “a human voice”
• [ ] Built in emotional subtext (felt vs. shown)
• [ ] Kept every scene sayable in ~8 seconds
• [ ] Structured the final prompt cleanly (segmented or JSON)

FAQ

Why does my AI video sound robotic even with a good model? Almost always the script, not the model. It’s written to be read, not spoken — long sentences, no pauses, no breath room, no emotional cues. Shorten the lines, add pauses where a real person would breathe, and mark the emphasis (more here).

How do I keep the same character across multiple clips? Reuse an identical, hyper-specific character description in every prompt, and/or use reference images (Veo 3.1’s “Ingredients to Video”). Vague descriptions drift; specific ones hold (Replicate guide).

Is JSON prompting actually necessary? No — but it helps for consistency and repeatable production. Google’s official format is structured prose, so treat JSON as a high-value option to test, not a requirement (Google’s guide).

How long can an AI video clip be? Most models still generate in short bursts — Veo 3.1 offers 4, 6, or 8-second clips. Plan your storytelling in ~8-second beats and stitch them.

---

Sources & further reading

• Google Cloud — Ultimate prompting guide for Veo 3.1
• Replicate — How to prompt Veo 3 for the best results
• Google Cloud Community (Dr. Wafae Bakkali) — Veo 3: A Detailed Prompting Guide
• Leonardo.Ai — Mastering Prompts for Veo 3
• ElevenLabs — Eleven v3 Audio Tags · Emotional context in speech · Best practices
• Deepgram — Text-to-Speech Prompting
• ImagineArt — JSON Prompting Guide for Veo 3
• ArchitJN — Veo 3 JSON Prompt Format That Beats Generic Prompts
• AdCreate — Veo 3.1 Prompting Guide