Prompt Dialects: Why One Video Prompt Gets Different Results Across Models, and How to Read a New Model's Style

So here's a thing that happens to everybody eventually. You write a prompt. A good one. You spent real time on it. You feed it to one model and you get this gorgeous, moody, cinematic shot, exactly what you pictured. Then you paste the same words into a different model, expecting roughly the same thing, and you get garbage. Flat lighting. Half your detail ignored. A camera move that does the opposite of what you asked. Same words. Wildly different result.

And the usual reaction is to assume one model is just better than the other. Sometimes that's true. But most of the time, that's not what happened. What happened is you spoke the wrong dialect.

We've been here before on the show. Way back when we broke down the anatomy of a prompt, we landed on a line I want to drag back out and put right at the center of today. "The components are the language. The dialect is just the accent." And the follow-up to it. "Learn the eight components, which are universal, and then translate them into whatever your tool likes."

That episode left dialect at the level of an accent. Two crude families. Paragraph models that want flowing sentences, like Veo and Sora. Keyword models that want terse, comma-separated, motion-first phrasing, like Runway used to. That was enough to get you started. It's not enough to make you good.

Today we go under the hood. Why do these accents even exist? Where do they come from? And the part that actually matters for your day to day, how do you walk up to a model you've never used, one that maybe didn't exist when this episode aired, and figure out its dialect in twenty minutes instead of guessing for a week?

That's the whole job today. Not memorizing Veo's syntax. Reading dialects. Because the syntax you memorize this month is wrong next month, and I'm going to show you a model that literally switched dialect families between versions to prove it.

Quick map of where we're going. We're going to dig into why the same prompt gets different results, and there are real, non-hand-wavy reasons. Then the two big dialect families with a twist for where things stand now. Then the JSON question, which is messier than the internet wants it to be. Then the heart of it, a five-step method to read any model. And we'll close with a worked translation and the specific ways people get burned. You already know the eight components, you know seeds, you know image-to-video and start frames, you know negative prompts, you know how to read a leaderboard. I'm going to lean on all of that and not re-explain it.

Let's start with the mechanism, because once you get this, everything else stops feeling like superstition.

Here's the root cause. A text-to-video model doesn't understand English the way you do. It learned to connect words with motion by studying millions of pairs. A video clip, and a text description of that clip. We call that text description a caption. The caption is the text that was paired with a training video. And here's the key move. Whatever style those captions were written in becomes the model's native language.

Think about what that means. If a model was trained on captions written like a cinematographer's shot notes, dense, full of lens talk and lighting language and film-stock references, then that's the language it speaks fluently. Feed it that style and it lights up. If a different model was trained on short, punchy, action-led captions, then that terse style is its native tongue, and the cinematographer's paragraph sounds like noise to it.

This isn't me guessing. The labs say it out loud in their research. The HunyuanVideo paper, which is a real technical paper on arXiv, describes using a large language model as, their words, the prompt rewrite model, to adapt your original prompt to what they call the model-preferred prompt. And they say why. To rephrase it so it conforms to a standardized information architecture, akin to the training captions. Akin to the training captions. They're literally rewriting your words to match how the captions were written.

The Waver paper is even blunter about it. They say the purpose of prompt rewriting is to align diverse user inputs as closely as possible with the captions used during model training. Read that again slowly. The whole point of the rewrite step is to drag your weird human phrasing back toward the caption style the model already knows. That's the mechanism. That's the accent. The accent is the caption style, baked in during training.

So when you feed a model the wrong dialect, you're handing it an accent it only half understands. It'll do its best. It'll approximate. But you've made the model work to translate before it can even start generating, and detail gets lost in that translation.

Now, the second mechanism, and this one is genuinely under-discussed. Silent rewriting. The invisible layer.

Here's the deal. On a lot of platforms, your words are not the words the video model sees. Before your prompt ever reaches the generator, the platform runs a separate language model over it that expands, polishes, and rewrites what you typed. People call this a prompt rewriter, a prompt enhancer, prompt upsampling. Different names, same idea. An LLM that rewrites your prompt before the video model gets it.

And often it's on by default, and you don't know it's there.

Concrete example. Run Veo through fal or through Replicate and there's an Enhance Prompt toggle. It defaults on. Fal's own Veo guide says it automatically enriches your prompt with extra cinematographic terminology and technical detail, and expands brief prompts into more detailed specifications that align with Veo's training distribution. There's that phrase again. Align with the training distribution. Same idea as the caption alignment, just running live, on your prompt, right now. And fal even tells you when to turn it off. Disable it, they say, when you need precise control over the model's interpretation without automated additions.

It gets deeper with Google's setup. When you use Google Flow, Gemini sits in front of Veo as an interpretation layer. A walkthrough of Flow describes Gemini parsing your camera direction, your composition, your subject, your setting, and your lighting, and then passing structured instructions down to Veo. The model infers what you meant from your language and reshapes it. And Google isn't hiding this. They actively promote what they call meta prompting. Which is, ask Gemini to write the Veo prompt for you. That's a rewrite step by design. They're recommending you let the LLM author your prompt.

And if you think this is some weird edge case, there's a research paper literally called PromptEnhancer, subtitle, a simple approach to enhance text-to-image models via chain-of-thought prompt rewriting. The takeaway from it is just that rewriting is a normal, deliberate stage in these pipelines. Not a hack. A design choice that's everywhere.

Okay, so why should you care? Here's why this matters for you specifically.

When enhancement is on, you cannot tell which parts of the result came from your words and which came from the rewriter's additions. You write a careful terse prompt, the rewriter fluffs it up into a paragraph, and you get a cinematic result. So you conclude, great, this model likes terse prompts. Wrong. The model never saw your terse prompt. It saw the rewriter's paragraph. You just learned a dialect rule that's actually the rewriter's behavior, not the model's.

Same trap with negative prompts. You add a careful exclusion, the rewriter rephrases everything, and your negative might have been dropped or inverted. You can't trust what you think you learned.

So the practical instruction, and we'll come back to this when we build the method. Find the enhance or rewrite toggle. Turn it off when you're trying to learn a model's true dialect. See what the raw model does with your raw words. Then, once you understand the bare model, turn enhancement back on if it helps. But probe with it off. This is the modern version of a theme we keep hitting on this show. Know what your words actually did.

Third mechanism. Length. Token and character limits.

Models only read so much text. Past a certain point your prose gets truncated, just cut off, or it gets de-prioritized, where the model technically reads it but weights it lower. The token or character limit is just how much of your prompt the model actually takes in before it stops paying attention. And this is dialect-relevant, because a terse model can choke on overload while a cinematic model rewards the extra length.

Here's where it gets funny, though, and useful. The guidance on length is all over the place. Google DeepMind's official Veo prompt guide favors longer, more detailed prompts for more control, and tells you to experiment with length, and states no hard cap. So Google says, go long, no real limit.

Then a third-party Veo guide from Powtoon claims that past roughly a hundred seventy-five words you risk overloading the generation with conflicting instructions. So, a hundred seventy-five word ceiling. But then fal's guide, for the same family of model, talks in characters, not words, and says the sweet spot is a hundred fifty to three hundred characters. Under a hundred characters and you get generic results. Over about four hundred and the model starts to, their words, prioritize certain elements unpredictably while ignoring others.

Now sit with that for a second. One guide says a hundred seventy-five words. Another says three hundred characters. Three hundred characters is maybe forty, fifty words. Those numbers don't just differ, they flatly contradict each other, for similar models. And that's the lesson, right there. Length guidance is folklore. It's people's gut feelings dressed up as rules. You do not trust a length number from a blog. You bench the actual model and find its real ceiling yourself.

There's a specific wrinkle for dialogue too. With Veo, dialogue has a time cap, not just a text cap. You've got roughly eight seconds of speech to work with. Replicate's guide warns that if you try to pack too much speech in, you get a character speaking way too fast, like they're auctioning the lines off. So when you write dialogue, you're not budgeting characters, you're budgeting seconds.

Fourth mechanism, and then we move on. Reproducibility. Stability. How much the model itself varies.

Same prompt, run twice, how close are the two results? That varies by model too, and it ties straight back to our seeds episode. Replicate notes that Veo will output very similar results for the same prompt, and they specifically add, unlike other models. So Veo is stable.

A multi-model benchmark from Magic Hour put numbers and character to this. They found Veo gave the most stable outputs with strong scene logic. Kling gave high quality but was inconsistent across repeated runs. Sora gave the highest realism but was less predictable. And Runway was the fastest, generations in roughly forty to seventy seconds, with the best usability. So pull that together. Dialect isn't only about how you phrase the prompt. It's also about how much randomness the model layers on top of your words. A model can speak your dialect beautifully and still wander run to run.

So that's the why. Four reasons one prompt gives four results. Caption style baked in during training. Silent rewriting before the model sees your words. Length limits and truncation. And plain old variance. None of that is magic. All of it is benchable.

Now let's get concrete about the two families, and then the twist that keeps this honest.

Family A. The cinematic camp. Structured, dense, prose-driven. These models want paragraphs that read like a director talking.

Veo is the headline here. Google's official guide lists seven components you express in natural language. Shot framing and motion, style, lighting, character description, location, action, and dialogue. And crucially they tell you to write prose, not fill in form fields. Longer, detailed prompts give greater control. That's the cinematic instinct.

Google Cloud's guide for the Veo three-point-one version gets more specific and gives you a front-loaded formula. Cinematography first, then subject, then action, then context, then style and ambiance. Front-loaded meaning the camera and shot stuff goes at the top, because the model weights the front of the prompt more heavily. That guide also tells you how to do negatives in this dialect, and it's a subtle point. You phrase a negative as a descriptive exclusion, not a command. So instead of saying no man-made structures, which is a command with a "no" in it, you write a desolate landscape with no buildings or roads. You describe the empty world you want rather than barking a prohibition. Same goal, different grammar, and the descriptive version works better here.

That guide supports a few more dialect features worth naming. Timestamp notation, where you bracket little time ranges like zero to two seconds, for multi-shot sequences. Dialogue goes in quotation marks. And you can label sound with tags for sound effects and ambient noise. Those labels are part of the dialect.

Let me read you an actual Veo three-point-one example, because the example is the dialect. Quote. Medium shot, a tired corporate worker, rubbing his temples in exhaustion, in front of a bulky 1980s computer in a cluttered office late at night. The scene is lit by the harsh fluorescent overhead lights and the green glow of the monochrome monitor. Retro aesthetic, shot as if on 1980s color film, slightly grainy. End quote.

Hear everything in there? Shot type, medium shot. Subject, the tired worker. Action, rubbing his temples. Location, the cluttered office at night. Lighting, harsh fluorescents and that green monitor glow. A film-stock reference, eighties color film. And grain. That sentence is the cinematic dialect rendered in full. It's not a list. It flows. And it's packed.

Sora, the version two release from OpenAI, sits in this same camp but with its own twist. Their official Cookbook guide, published in October of 2025 by Robin Koenig and Joanne Shin, uses a modular prose template. And they go out of their way to say it is explicitly not JSON. You write a plain-language scene description first, then labeled blocks. A cinematography block for camera and mood, an actions block with beats, a dialogue block with short natural lines.

Their core philosophy is the best one-liner in any of these guides. Think of prompting like briefing a cinematographer who has never seen your storyboard. If you leave out details, they'll improvise. That's the whole cinematic mindset in one sentence. The model is a collaborator who fills gaps, and the more gaps you leave, the more it invents.

But here's the nuance that makes Sora interesting, and it pushes back on the idea that cinematic always means maximal. Sora explicitly endorses both ends. Detailed prompts give consistent, controlled results. But lighter prompts give creative freedom and surprising variations, because, they say, leaving certain elements open-ended encourages the model to be more creative. So even inside one model, you've got a slider. Tight when you need control. Loose when you want the model to surprise you. That's a real choice, not a mistake.

Short Sora example, verbatim. In a 90s documentary-style interview, an old Swedish man sits in a study and says, quote, I still remember when I was young, end quote. Notice that's not a wall of text. It's tight. The dialogue's short, on purpose, because in Sora duration is an API parameter, you pick four, eight, twelve, sixteen, or twenty seconds, it's not something you write in the prose. And the spoken line has to fit the clip, so you keep it short.

Now Family B. The terse camp. Motion-led. Describe what moves.

Runway, the Gen-4 and Gen-4.5 generation, is the cleanest example, and it's our anchor for "less is more." Runway's official guidance says good prompting is less about stuffing in descriptive keywords and more about clearly directing motion, camera behavior, and how things change over time. That's a totally different instinct from Veo. Veo says describe the world richly. Runway says tell me what moves.

A few specifics worth burning into memory. For image-to-video, Runway tells you to use the image to define the scene and use the text only to describe what moves. Their phrase. Think less about how things look and more about what happens next. That's a direct callback to our image-to-video episode. Remember how we split the components into a still half and a motion half? Subject, framing, lighting, mood, setting on the still side. Action, camera, pacing on the motion side. Well, in Runway's image-to-video dialect, the start frame carries the entire still half, and your prompt carries only the motion half. The division of labor we talked about abstractly is literally how this dialect works.

More Runway specifics. Conversational filler wastes prompt space, so cut it. And conceptual or emotional language is discouraged. They tell you to translate conceptual ideas into clear, specific physical actions. Don't write "she feels lonely." Write what loneliness looks like in motion. She walks away, slowly, alone in the frame.

And here's the big one, the per-dialect difference that'll trip you up. Negative prompts are not supported in Gen-4. And worse, Runway warns they may produce unpredictable or even opposite results. Sit with that against what we just said about Veo. Veo takes negatives, phrased as descriptive exclusions, and likes them. Runway doesn't take them at all and they can backfire. This is a direct callback to our negative-prompt episode. The exact technique we taught you, valuable in one dialect, is harmful in another. Same technique. Opposite outcome. That's what dialect means in practice.

Luma's Dream Machine, the Ray2 model, sits in a middle spot. Concise but ordered. Their best practice is three to four sentences. Avoid vague or emotional language, focus on what can be seen, same instinct as Runway. But they give you a specific order to follow. Subject, then action, then subject details, then scene, then style, then camera move, then a reinforcer at the end. Their example. A man in a red coat runs through a foggy forest, cinematic lighting, tracking shot, camera follows him from behind. See how that's structured but compact? And Ray2 specifically shines when you spell out camera dynamics with natural phrasing. Crane down. Camera circles slowly. It tends to carry motion across time once the motion is established. So with Luma, you name the camera move plainly and it runs with it.

Pika is the historical home of the parameter-suffix dialect. The old Pika Labs used command-line-style suffixes. A guidance-scale flag, a negative-prompt flag, an aspect-ratio flag, a seed flag, a motion flag, all tacked on the end of your prompt with double dashes. Current Pika, the two-point-two version, has softened that. Now they tell you to keep prompts short and clear. One subject, one action, simple background. And don't stack actions, they specifically warn against piling up running plus jumping plus dancing plus flying. There's an optional structure if you want a bit more. Subject, action, environment, camera, style. Their example. A golden retriever wearing sunglasses, walking through Times Square at night, neon reflections on the sidewalk, cinematic slow zoom. Compact. One subject, one main action, a little flavor.

And those parameter suffixes are themselves a dialect feature. Some tools read a double-dash aspect-ratio flag or a double-dash negative flag as discrete controls, separate from the prose. But paste those same flags into Veo or Sora and they don't get parsed as controls. They just become literal junk text sitting in your prompt, confusing the model. We'll come back to that as a specific pitfall.

Now the twist, and this is the part that keeps you honest. Which model leans which way is moving fast. Treat every standing as a snapshot. And send yourself, and your listeners if you've got them, to bench your own shots and to the Artificial Analysis Text-to-Video leaderboard, which runs blind Elo from same-prompt A-B votes, the same kind of leaderboard we covered early on.

Here's the hard evidence that dialects drift. Kling flipped. Genuinely flipped families. Older guides treated Kling as a terse, motion-led model, squarely in Family B. But the Kling three-point-oh guide now says it understands cinematic language remarkably well, wants prompts written like directions to a scene rather than a list of objects, and rewards filmmaking concepts. Scene coverage, composition, pacing, continuity. That's Family A talk. So between versions, one model walked from the terse camp into the cinematic camp.

Think about what that does to anyone who memorized "Kling is terse." They're now wrong, and they don't know it, and their prompts quietly got worse. This is the single cleanest argument for the whole episode. Read the current guide. Don't memorize last version's dialect.

And the leaderboard names themselves make the point. As of the middle of 2026, the top of the Text-to-Video Arena is held by models with names you've probably never heard. The leader is something called HappyHorse, version one-point-oh, with an Elo around twelve hundred ninety-three. Then Dreamina Seedance version two-point-oh. Kling three-point-oh. A grok video model. And on the with-audio board, Seedance two-point-oh leads with an Elo around twelve hundred fifteen. I'm not naming those because you should run out and use HappyHorse. I'm naming them because by the time you hear this, the leader will be different again. Which is exactly the point. The skill is reading dialects, not memorizing whoever's on top this week.

And there's a counterweight to the Runway "less is more" gospel. A 2026 trend piece argues the broad direction is actually toward more structure, not less. Their framing. Modern models process four layers at once. The subject's look, the camera movement, the light's behavior, and the physical motion. And if your prompt only covers the first layer, the model fills in the other three at random. They also say flat out that different models require different prompt dialects, with different strengths. Veo strong on physical light and material behavior. Kling strong on human movement and emotion. So you've got Runway telling you to strip it down, and this trend piece telling you to layer it up. And both are right. For different tools. Which is the whole reason you can't memorize one rule.

Okay. Let's talk about JSON, because it comes up constantly and the conversation is usually dumb in both directions. Let me try to give it to you straight.

The pro-JSON case. The idea is you write your prompt as structured data. A camera field, a lighting field, a subject field, an audio field, each one its own labeled slot. Two claimed benefits. First, it prevents what people call concept bleed, where describing the mood accidentally shifts an object's color, because in JSON the mood lives in its own field, sealed off from the subject. Second, it makes batch generation programmatic. You can loop a spreadsheet through the subject field and crank out a product showcase, fifty variations, same camera and lighting, just swapping the subject. Guides from ImagineArt and LTX push this, and camera control is the thing they cite most often as where structure actually helps.

Now the skeptic case, and I want to give it equal weight because it's more correct than the hype. Models do not parse JSON as data. They're not reading your brackets like a program would. As one writer put it, language models are trained to generate statistically likely text sequences, not syntactically valid data structures. JSON only works to the extent that it's organized text the model has seen patterns of in training. The brackets aren't magic. They're just a tidy way to lay out text.

The best honest verdict I've seen comes from Gabe Michael, who's tested both directions. He says, quote, structure matters, but format is flexible. I don't believe JSON is a magic key. End quote. And he's seen it both ways. Structured JSON prompts beating natural language sometimes, and natural language beating JSON other times. And he throws in this gem. Veo often does whatever it wants anyway. So the honest read is, organized thinking helps. The model does not read brackets. Those are two different claims and people constantly collapse them into one.

And here's the kicker that should settle it for you. The official guides for the two most cinematic models both say use natural-language prose, not JSON. Veo three-point-one, prose. Sora two, explicitly not JSON. The labs themselves, the people who built these things, say write sentences. And yet there are countless third-party "Veo JSON prompting" guides all over the internet. That gap, between what the fan guides push and what the actual lab documents, that gap is itself the lesson. Trust the lab's own doc and your own probe over a viral template every single time.

The pragmatic workflow from the reasonable wing of the structure camp is actually good advice. Start in natural language while you're exploring, finding the shot. Then convert to JSON or labeled fields only once you've found a direction worth locking in for consistency or for batching. Explore loose, lock structured. That's sane.

There's one more structured dialect worth a mention, the beat or time-coded script. A cross-model walkthrough frames Kling as wanting beat-marked timelines. Like, beat from four to eight seconds, camera pushes in. Audio at four-point-five seconds, a metallic thud sound effect. That lines up with the timestamp notation Veo and Kling support. The same article frames Runway as wanting force and physics verbs, and Sora as wanting cause-and-effect physics statements. Treat those specific examples as illustrative and version-dependent, not gospel. Remember, that same article pushes JSON for Veo, and the official Veo guide says prose. So even within one helpful article, you'll find advice that the lab contradicts. Verify against the source.

Alright. This is the heart of the episode. How do you read a dialect from first principles? Here's a repeatable method that works on any model, including one that doesn't exist yet. Five moves.

Move one. Read the official prompt guide. Once. Just once, all the way through. Every major lab publishes one, and it names the preferred structure and the preferred vocabulary right there. Google DeepMind has a Veo guide. Google Cloud has the longer Veo three-point-one guide. OpenAI has the Sora two guide in their Cookbook. Runway has the Gen-4 guide. Luma has Ray2 best practices. Fal has a Kling three-point-oh guide. And the per-model pages on fal and on Replicate are genuinely useful. Read the official one first, before any third-party tutorial. The lab knows its own model better than a content farm does.

Move two. Study the example gallery, and copy the caption style, not the content. This is the move people skip and it's the most valuable one. The official examples are the dialect rendered in full. Forget what the examples are about. Look at how they're written. Is it one flowing paragraph, Veo and Sora style? Or comma-separated keywords, Runway and Luma style? Is there cinematic film-stock vocabulary, shot on thirty-five millimeter, grainy, or is that totally absent? Are camera moves named explicitly, dolly in, crane down, or just implied? Is dialogue in quotes? Once you see the grammar, you reuse the grammar and swap in your own subject. You're not copying their shot. You're copying their sentence structure.

Move three. Check the length limit and the order. Note the word or character ceiling, if there even is one, and notice whether the guide front-loads anything. Veo three-point-one front-loads cinematography. Luma front-loads the subject. Order matters because the front of the prompt gets weighted more. And past the limit your text gets truncated or down-weighted, so don't write a novel for a terse model. You'll just be feeding it words it throws away.

Move four. Find out if the platform rewrites or enhances your prompt, and turn it off to probe. This is the silent layer we hammered earlier. Look for an Enhance Prompt or a Rewrite toggle. Remember it's on by default in Veo through fal and through Flow. With it off, you see the raw dialect, the model's actual response to your actual words. With it on, you're really testing the rewriter, not the model. So probe with it off. Learn the bare model first. Then decide whether the enhancer earns its place.

Move five. Run a controlled probe. The bench. And this is where everything we've taught about rigor comes home. Hold everything constant. Same seed, callback to the seeds episode. Same duration and aspect ratio, callback to the constraints episode. Same start frame if you're doing image-to-video. Then send two versions of one single shot. Version A, a thin, plain prompt. Version B, a dense, cinematic-paragraph version of the same shot. And compare.

Here's how you read the result. If the thin one already nails it, and the dense one just adds mush and confusion, you're on a terse model. Strip it down. But if the thin one comes out generic and vague, and the dense one snaps into focus, the model wants structure. Feed it the paragraph. That one little A-B test tells you the family in one sitting.

And borrow the benchmark hygiene we keep preaching. Don't judge off one generation. Run three to five per version, because these models vary run to run, remember Kling's inconsistency. Hold your parameters fixed. And here's the discipline most people skip, record the failures, not just the best cases. The Magic Hour methodology makes this point. Your highlight reel lies to you. The failure rate is the truth. A model that nails it one time in five is not a model you can ship with.

That's the method. Read the guide, copy the caption style, check length and order, kill the rewriter to probe, then bench A-B with failures logged. Five moves. Works on HappyHorse, works on whatever replaces HappyHorse.

Now let's make this a habit you can actually run, with a worked example.

The keystone habit is this. Keep one model-agnostic core shot description, built from the eight components. And then re-dress it into each model's dialect. You never re-conceive the shot. You just re-accent it. Build the shot once, in neutral component terms, and translate.

And maintain a small template library. Just three templates is plenty. One cinematic-paragraph template. One terse comma-keyword template. One structured field template. When a new tool comes along, you figure out its family with the five-step method, then pour your core shot into the matching template. That's it. You're not starting from scratch each time.

Let me walk one through. Here's our core shot, in pure component terms. Subject, a lone woman in a red coat. Action, she walks slowly toward camera. Setting, an empty train station at dawn. Camera, a slow low-angle dolly-in, meaning the camera sits low and pushes in toward her gradually. Framing and lens, wide, with shallow depth of field, so she's sharp and the background falls soft. Lighting, cold blue dawn light coming through high windows. Mood and grade, lonely and desaturated. Pacing, slow.

That's the shot. Model-agnostic. Now let's dress it two ways.

Cinematic paragraph dialect, for Veo, Sora, Kling three-point-oh. Quote. Low-angle wide shot, slow dolly-in on a lone woman in a red wool coat as she walks slowly toward camera through an empty train station at dawn. Cold blue light rakes through tall arched windows, long shadows on the marble floor. Shallow depth of field, desaturated cinematic color grade, melancholic and still, shot on thirty-five millimeter film with subtle grain. Slow, deliberate pacing. End quote. Notice that follows the Google Cloud Veo grammar exactly. Shot type, subject, action, context, lighting language, the film-stock reference, mood, pacing. Everything in its expected place, front-loaded with the camera.

Now the same shot in the terse, motion-led dialect, for Runway image-to-video, Luma, Pika. And here's the key. The start frame supplies the still half. The image already has the woman, the red coat, the train station, the cold light, the grade. So the prompt is only motion. Quote. Woman walks slowly toward camera, low-angle camera dollies in slowly, slow pacing. End quote. That's it. Per Runway, the image defines the scene and the text only describes what moves. No emotional language. No conceptual language. And no negative prompt, because Gen-4 doesn't take one.

Now look at those two side by side. It's literally the same shot. Same woman, same station, same dolly, same mood. One's a rich paragraph, one's a single motion sentence. And here's the punchline you have to internalize. The cinematic model would read that terse version as badly under-specified, shrug, and improvise the lighting and the grade however it felt like, probably not the cold blue dawn you wanted. And the terse model would read that cinematic paragraph as noise, and either ignore half of it or mangle it, fighting your start frame instead of just animating it. Same shot. Wrong dialect either direction equals a worse result. That's the entire thesis in one example.

So let's close on the pitfalls, the specific ways you will actually get burned, and the fix for each, because forewarned is fixed.

Pitfall one. Cinematic prompt into a terse model. You take that hundred-seventy-five-word, film-stock-laden Veo paragraph and paste it into Runway Gen-4. It overruns Runway's whole "describe what moves" expectation. Runway's own guidance says overloaded descriptive keywords hurt, and conceptual language causes random or unexpected movements. So your beautiful detail doesn't render. It dilutes. It actively makes things worse. The fix. Strip to the motion half, and move the entire look into a start frame. Let the image carry what the prose can't.

Pitfall two, the mirror image. Thin prompt into a structure-hungry model. You drop a one-liner into Veo or Kling three-point-oh or Seedance, and you leave those four layers under-specified, so, as the trend piece put it, the model fills in the rest at random. Fal's Veo note adds that sub-hundred-character prompts produce generic results. The fix. Dress it up with the cinematic template. Give the model the structure it's starving for.

Pitfall three. Porting parameter suffixes blindly. You paste double-dash-aspect-ratio sixteen-by-nine, double-dash-neg blurry, double-dash-guidance-scale sixteen into a model that doesn't read flags. Those don't become controls. They just dump literal text into your prompt body, garbage the model tries to interpret as part of the scene. Suffixes are a dialect feature of specific tools, legacy Pika mainly, not a universal language. The fix. Know whether your tool parses flags, and if it doesn't, express those settings through the tool's actual controls, not in the prose.

Pitfall four. Negative prompts ported across dialects. We covered this. Valid and recommended in Veo, as descriptive exclusions. Explicitly unsupported and possibly harmful in Runway Gen-4. It's a technique from our negative-prompt episode that simply does not survive a model swap. The fix. Check whether the target model supports negatives at all before you reach for that tool.

Pitfall five. Silent rewriting masking what your words did. With enhance or rewrite on, you'll credit or blame your own phrasing for results the platform's LLM actually authored. You'll "learn" a dialect rule that's really the rewriter's behavior, and then you'll carry that wrong rule to the next model and be confused when it fails. The fix, again. Probe with it off.

Pitfall six. Trusting one blog's length number. Remember a hundred seventy-five words versus three hundred characters, two guides flatly contradicting each other for similar models. Length rules are folklore. The fix. Bench the actual model and find its real ceiling yourself.

And pitfall seven, the one that ties the whole episode together. Assuming last version's dialect still holds. Kling walked from terse to cinematic between versions. If you memorized the old Kling, you're now wrong and you don't know it. The fix is the simplest of all. Re-read the guide on every version bump. Treat a version number change as a signal to re-run your five-step read.

So here's where we've landed. The reason one prompt gives you different results isn't mystery and it isn't just quality. It's caption style baked in during training, silent rewriting before the model sees you, length limits, and plain variance. The two families, cinematic-dense and terse-motion-led, are a starting frame, not a law, and Kling jumping families proves the law would be wrong anyway. JSON helps as organized thinking, not as brackets the model parses, and the labs themselves say write prose. And the durable skill, the thing that survives every model swap from now until forever, is the five-step read. Guide, gallery, length and order, kill the rewriter, bench it. Plus the translation habit. One core shot, re-accented into whatever the tool speaks.

The components are still the language. The dialect is still just the accent. You've now got the eight components down cold from earlier in the show. Today you got the method to pick up any accent on the spot. That's the part that doesn't expire next month.