u/Practical_Low29

Been doing AI video for two years and this is the first time my whole workflow flipped.

The old way: write the shot list, pull a first frame, sometimes a last frame, then hand the video model a wall of prompt text. What happens at second 0 to 3, how the camera moves, which line lands where. Plus the question that never had a clean answer, how many seconds should this shot even be. Four felt short, eight felt wasteful, so you guessed.

What changed is Seed-Audio 1.0. It's ByteDance's audio model, on Atlas now, and it isn't TTS. One generation gives you a full mixed track: multiple characters' dialogue auto-arranged, laughs, breaths, pauses, accent, background music underneath, sound effects slotted in. The laugh isn't a clip you drop in, the model performs it from the prompt. https://www.atlascloud.ai/models/bytedance/seed-audio-1.0

The trick is that a Seed-Audio prompt is a timeline. You write it in narrative order and the sound comes out in that order. So I generate the whole shot's audio first, dialogue and SFX and BGM in one track, and that track becomes the spine of the shot.

Then Seedance 2.0 reference-to-video takes three things per shot: one image, that one audio track, and a short plain-language description. That's it. All the second-by-second stuff moved into the audio, the line shows up at whatever second I wrote it, the action is pinned to the sound effect. My video prompt is now two or three sentences of mood and scene. https://www.atlascloud.ai/models/seedance2

The part that quietly fixed the most was clip length. You stop guessing. Generate the audio, set the video duration to match, done. Pixar has done this for decades with story reels, cut the audio first and edit picture to sound. Not a new idea, it's just that the studio step is now one prompt.

A couple things the docs skip that cost me takes: mark BGM explicitly with "Soundtrack" or the model treats a mood line as a two-second effect, and if you want a sound mid-line, split the dialogue in two and put the effect between them, it won't infer overlap from "meanwhile."

Ran five shots through it. Voice stays consistent across all of them once you register it with a reference clip, and there wasn't a single second-by-second prompt in the whole thing.

Most people feed one square reference and then wonder why either the character or the environment drifts across a sequence. The fix that made both hold for me was using two references at different aspect ratios, each shaped to what it actually needs to lock.

Card one is the character, at a tall 4:3. Just the protagonist, appearance, costume, expression, nothing else. A near-portrait ratio gives the face and the wardrobe room to be detailed, so this card locks who the character is.

Card two is the set, at an ultra-wide 3:1. The entire environment in one long image, the whole obstacle run laid out end to end, the staging and the atmosphere. That extreme width is the point. It lets the model see the geography of the full course in a single frame, so this card locks where everything is and how the space is arranged before any motion exists.

Then both go into image-to-video. Because the character is pinned in one card and the whole course is pinned in the other, both stay consistent across a run that hits several obstacles. I tested it on a period-costume obstacle-course show, a contestant confidently running spinning discs, crossing logs, charging a slope, then slipping into the water on the final beat, and the character and the set both held the whole way through.

Stop cramming everything into one square frame. Give each reference the shape of its job, and the consistency comes for free.

Most of the time we fight tooth and nail for realism. Sometimes it is a lot more fun to go the other way and make something gloriously impossible. This is a city that bends and folds in on itself, and the wrongness is the entire point.

A dense downtown at dusk, skyscrapers curving and leaning over the street like they are slowly melting toward each other, a river of yellow taxis flowing through the intersection, one small figure crossing below. Every surface is photoreal, the glass, the stone, the wet asphalt, but the space they sit in is impossible. That contrast is the whole trick.

The thing that keeps it dreamlike instead of just broken is to break only the geometry and keep everything else grounded. Photoreal textures, believable lighting, real reflections, correct motion blur on the cars. If you warp all of it at once you get glitch soup that reads as an error. If the materials stay honest and only the space bends, the brain reads it as a dream, not a bug. Controlled wrongness beats random noise.

Motion seals it. A slow, floaty, slightly-too-smooth camera drift gives it dream logic, like you are moving through it rather than filming it. Realism is one lane. Deliberate impossibility is another, and honestly it is the more fun one to drive.

The one setting that decides dream vs glitch: lock the material and lighting realism high and only let the geometry/space distort, otherwise it collapses into noise. Ran it on Seedance 2.0 through an OpenAI-compatible endpoint.

Most previz talk is about nailing one shot. The thing that actually breaks AI video is the opposite, the cut between shots. Every clip generates on its own, so the character ends shot one facing left near the wall, and shot two opens with her facing right in the middle of the street. The lens jumps, the screen direction flips, the eyeline is off. Each shot looks fine alone and the sequence feels stitched together by a stranger.

So I stopped planning shots and started planning the sequence. A lightweight 3D previz is enough for this, and it does not need Blender or Unreal or any MCP setup, a browser scene with plain mannequins works. I block the whole run of shots in one location: where the actor stands and moves, the composition, the lens on each shot, the camera move, and the one thing single-shot previz ignores, the handoff. Where the character is at the last frame of shot one is exactly where shot two has to begin. Same position, same screen direction, matched lens.

Then each planned shot goes into Seedance with its previz as the reference. Because the continuity was solved in the blocking, the cuts actually line up. She exits frame left and enters the next shot from frame right like a real edit, instead of teleporting.

Block the sequence, not the shot. Plan the handoff and the cut stops fighting you.

The look I keep coming back to is 2.5D: a character that moves with real 3D weight but is painted like a hand-drawn frame. The trick is separating the two layers. A 3D skeleton drives all the motion underneath, so the movement is correct and stable, but the entire visible surface is a hand-drawn 2D marker and gouache paint layer, cel-shaded with two or three tone bands, no black outline anywhere, visible brush strokes and paper grain. The 3D is never exposed.

I ran it as a video-game-style 360 idle loop, an original footballer standing in a relaxed star-player stance while the camera does one constant-speed full orbit in ten seconds, ending exactly where it started for a seamless loop. Subtle idle motion only: chest breathing, a slow weight shift, hair swaying, jersey rippling. The face stays locked to the skeleton so it never jitters or deforms as the camera goes around the back and returns.

The detail that sells the hand-drawn feel is running it on-twos, a stepped framerate, so it breathes like traditional animation instead of gliding like smooth CG. You get the best of both: 3D-correct motion and turnaround, painted like a single artist drew every frame.

Painted surface, 3D bones, one clean looping orbit. That split is the whole technique.

quick one. been testing how seedance handles fast fabric motion, the kind where a dress flares out mid-step and the satin has to keep its weight instead of turning to plastic.

red satin, strapless, sunlit street backdrop. the flare is where most models lose it, the fabric either freezes flat or smears into a blur.

this run kept the satin sheen and the fold weight through the whole flare, which is the part i was testing.

9 second clip. spicy, nsfw tag on. the satin physics is the win here, the rest of it still has the usual ai softness in the face.

ran the satin physics test on Atlas Wan Spicy, the uncensored lineup is here if anyone wants to try the same fabric-motion setup.

not affiliated, just the host i ran it through.

The one thing you genuinely cannot prompt your way to in AI video is handheld camera motion. The specific drift, the realistic shake, the way a human operator walks around a scene, you can describe it all day and the model will not feel it. You need to hand it a real camera move as a reference. Everyone does that in Blender. I hate Blender.

So I skipped it and used my iPhone. ARKit tracks camera motion in 3D space scarily well, so you can literally walk around a blocked-out scene holding your phone and record a complex move exactly like a real operator would, shake and all. There is an open-source SwiftUI tool for this, film-space by maxprokopp, an AR camera and scene recorder, and he built it with Claude and put it out for anyone to use.

The flow is simple: set up the scene in 3D space on the phone, record the camera move by physically walking it, generate a start frame with the positions and characters, then feed the start frame plus the recorded motion into Seedance. Seedance fills in the scene and inherits that real handheld feel off the iPhone track.

No 3D software, no rig, just walking around a room with a phone like a camera operator. The gritty human motion that used to be the hardest thing to fake is now the easiest part.

The open-source AR camera/scene recorder I used is maxprokopp/film-space (SwiftUI, built with Claude, he put it up for anyone to build on): https://github.com/maxprokopp/film-space

The video step runs on an OpenAI-compatible key so the start frame + recorded camera motion go straight into Seedance.

Fun little reskin test: take an old-school hand-drawn cartoon cat scene, the exaggerated squash-and-stretch kind, and convert it into a photoreal fluffy kitten while keeping the exact same pose and timing frame for frame. Cartoon physics, real fur.

The charm is the mismatch. The kitten holds the cartoon's overacted body language, the wide-eyed double-take, the dramatic broom-clutch, the springy stance, except now it is rendered as an actual fuzzy animal with real fur and weight. The contrast of cartoon motion on a believable kitten is the whole joke, and it lands.

The technical bit is the reskin holding the original animation's pose and rhythm instead of inventing its own. Same beats, real skin. A real kitten doing cartoon takes is unfairly cute.

Reskinned on Seedance 2.0.

Another Blender-into-Seedance test, and it taught me where the effort actually pays off. I went in assuming I needed to animate the face in Blender to get control over the performance. I did it, and then realized it was mostly wasted, the render image alone got the same result. The facial pass nudges the render a little, but it is not load-bearing.

Where the time actually mattered was cloth physics and lighting. Letting a jacket and fabric move with real weight in Blender, and getting the light direction right before handing it off, fed Seedance something it could not have invented as convincingly from a prompt. That is the part worth your hours.

So the lesson flipped my instinct: do less character animation in Blender, do more of the physical stuff. Block the motion roughly, get the cloth and the light honest, and let Seedance do the finishing. The potential of this hybrid is genuinely silly once you stop over-animating the parts that do not need it.

The hybrid runs through Seedance on one OpenAI-compatible key, so the Blender render goes straight in.

Less time on the face, more on the fabric. That is the whole adjustment.

The cheapest way I have found to stop wasting video credits: turn the video prompt into a storyboard first. There is a GPT Image 2 prompt that takes any text-to-video prompt and renders it as a full storyboard contact sheet, one consistent cinematic frame per key moment, before you generate a single second of actual video.

Why it saves money: video gen is the expensive step, and you usually find out the prompt was wrong only after paying for the clip. The storyboard surfaces the problems for the price of one image, wrong character count, a missing prop, the climax landing on the wrong beat. You fix the prompt, then generate the video once instead of five times.

It doubles as a consistency check. If the storyboard cannot hold the character across panels, the video will not either, so you catch drift before it costs you.

I run the storyboard on GPT Image 2 and the video on Seedance, same key, so the preview-then-generate loop never leaves one setup. Full storyboard prompt is in the comments.

Counterintuitive thing from blocking animation for Seedance: plain boxes work better than detailed 3D mannequins as the reference. I expected the opposite, figured the more accurate the rig the better the result.

Why boxes win: a detailed mannequin reads as a static figure the model feels it has to respect, which fights the prompt telling the characters to move. Plain boxes carry the one thing that actually matters, camera movement and spatial relation in 3D, without the conflicting "this body is frozen" signal. The model fills in the rest from the start frame, and intuits which box is which.

So the workflow is barely any 3D at all: generate a start frame, drop a few boxes in Blender where the characters are, animate the camera, hand both to Seedance. Your reference does not need to look good. It needs to carry the camera and the spacing.

The takeaway that flips the usual advice: for AI video, an ugly accurate-camera blockout beats a pretty detailed one.

Tried a cross-model motion trick that mostly worked: generate a clean human-model mannequin rig in Gemini Omni, then feed that as the motion reference into Seedance 2 so the character inherits the rig's movement instead of the model improvising it. Kling 3 handled the fluid in-between motion. Same character, three models, each doing the one thing it is best at.

Why bother: if you let a video model invent body motion from a text prompt, it drifts and stiffens, especially on dance or fast gestures. Driving it off an actual mannequin rig keeps the motion clean and repeatable. The catch is the parts the rig cannot capture, the small stuff you fall back to prompting, and those are exactly where it goes stiff.

The reason this is even practical: all three models run on one OpenAI-compatible key, so passing motion from Gemini Omni to Seedance to Kling is a model-string change, not three accounts and three bills.

Cross-model motion reference is going to be the thing that separates clean character animation from the usual AI-video wobble.

Tried the sports-anime hype format in Seedance 2.0: two original rival strikers, the locker-room charge-up before an epic match, all that exaggerated shonen energy. The fun is leaning all the way into the genre instead of fighting it.

What made it land:

- Commit to the genre look. Spiky stylized hair, dramatic rim light, sweat and steam, the over-the-top intensity sports anime lives on. Half-measures read as generic 3D.

- Stage the hype before the action. The locker-room charge-up, fists clenched, glowing aura, sells the match before a ball is even kicked. The build-up is the hook.

- Keep two clearly distinct rival designs so the matchup reads instantly, opposite color energy, opposite posture.

- One continuous escalating beat rather than quick cuts, so the intensity ramps instead of resetting.

Animated in Seedance 2.0, original characters so nothing is borrowed.

What sport would you give the full anime-hype treatment?

Ran the same atmospheric scene through three models on one key: a lone figure on misty water under a huge moon, wuxia mood. Kling 3.0, Seedance 2, Gemini Omni Flash.

Each took the mood somewhere different, the water, the moon, and the stillness all read differently. No obvious winner.

All three sit on one OpenAI-compatible key, so it was just a model swap. Which version reads best to you?

Been using GPT Image 2 as a pre-production tool instead of just a single-image generator, and the trick that worked best: ask for one combined development board, a character design sheet plus a multi-panel storyboard, in a single image. For a short called The Cat and the Festival Bell, a village boy and a stray kitten, I got a full character sheet (expressions, poses, color palette) and an eight-panel storyboard with camera and timing notes, all in one render.

What made it hold together:

- Ask for ONE combined image with named sections, a character-sheet section and a storyboard section. It keeps the style consistent across both.

- Specify original characters only, inspired by nostalgic countryside anime, no copyrighted character resemblance. Keeps it clean and original.

- Put camera notes, motion arrows, and timing into the prompt so the board reads like a real studio planning sheet.

- Lock the palette and outfit once so every panel matches.

Then I used that board as the visual reference and animated the beats into a short. Keeping the storyboard as the reference is what kept the character on-model through the motion.

Full prompts (storyboard plus animation) are in the comments.

What are you using GPT Image 2 for beyond single images?

Ran the same hard physics prompt through three video models on one key: a sprinter mid-run, shot from the side and tracking alongside, the kind of clip where gait, weight, and fabric give the model away. Seedance 2.0, Gemini Omni Flash, and Kling 3.0, several tries each. No clean winner, which surprised me.

Gemini Omni Flash: my favorite overall. Understood the prompt instantly, no false content flags, and the body physics held up best. The one knock is the slightly slow, low-frame-rate look Google models drift into.

Seedance 2.0: easily the best-looking of the three. Most visually striking, cleanest lighting, most cinematic frame. Honest take though, I expected the physics to be the most accurate and it was not quite top there. Gorgeous, not the most physically correct.

Kling 3.0 Pro: the frustrating one. It kept flagging a plain running scene as adult content and misread the prompt a few times. When it finally rendered, lighting and frame rate were great, but the body motion looked off and a bit unstable.

The reason I could do this side by side at all: all three sit on one OpenAI-compatible key, so it was just swapping the model name, no three separate setups and bills.

My read is pick by shot: Omni for believable motion, Seedance when you want the prettiest frame. Which would you rank first?

This upside-down pet photobomb selfie keeps making people stop scrolling. A low-angle phone selfie looking up, you in the bottom center, and a fuzzy pet leaning into frame from the top, peering straight down at the lens. The contrast between your normal selfie and a giant curious pet face is the whole thing.

Nano Banana 2 prompt:

A realistic vertical phone selfie, very low camera angle pointing up. A young person stands in the lower center in a casual loose tee, looking down at the lens with a playful pout, relaxed social-media selfie vibe. At the top center, a fuzzy pet (cat or dog) leans down into frame upside-down, looking straight down at the camera with a cute, goofy, curious expression, filling the top of the frame. Bright modern apartment, big windows, soft natural light, clean background, realistic skin and fur texture, natural phone-camera lighting, balanced composition. Negative: eye-level camera, flat angle, side-on animal, cartoon, distorted anatomy, extra limbs, scary expression.

Two tips that mattered: say upside-down and looking straight down for the pet or it renders side-on, and keep the camera angle very low so the lens points up at both faces.

Made it with Nano Banana 2. What pet would you put up there?

Heads up, flashing lights in the clip.

Been chasing that object-detection HUD look, the one where bounding boxes lock onto things in frame with little labels like a targeting overlay. Finally got it clean, so here's the approach.

Footage: GPT Image 2 for the stills, then Wan image-to-video to animate them. I run both through one OpenAI-compatible key on Atlas Cloud, so the ComfyUI side is just two API nodes and I'm not juggling separate accounts.

The HUD is an After Effects pass on top: solid color boxes, a thin crosshair, monospace labels, a little jitter on the box edges so it reads like a live readout instead of a static graphic. Animate the box scale-in fast, about a quarter second. That snap is what sells the detection feel.

Keep the labels deadpan and specific, GRAY SWEATPANTS, FOOTWEAR, that kind of thing. The more mundane the object, the funnier it lands.

What would you point the detector at? I want dumber objects.