DEV Community: Jason Wei

Making 15-Second AI Rap Videos Reliable: Structured Prompts, a Credit Ledger, and Safe Refunds

Jason Wei — Thu, 05 Nov 2026 10:01:34 +0000

I recently launched AI Rap Generators, a small tool that turns two adult portraits into a 15-second vertical rap video with an original verse and beat. You pick a "stage" (roast battle, birthday, pet duet, rooftop), optionally add a name or inside joke, and a few minutes later you get a 9:16 MP4.

This post is a write-up of the three things that mattered most while building it:

Why I made the product narrow on purpose
How I structure prompts so a video model behaves
How I think about credits and failed renders when every generation costs real money

The code in this post is a simplified sketch of the patterns, not a copy of production code.

1. Narrow beats general (for a solo builder)

General-purpose text-to-video tools are impressive, but they hand the user a long list of decisions: the prompt, the camera, the music, how to keep a face consistent across shots. Open-ended input also means an unbounded number of ways to fail.

So I locked the format to two people, one stage, one rap:

The user only does two things: upload portraits and pick a stage.
I can turn almost every other decision into a per-scene template and tune for reliability.
The output (15 seconds, 9:16) already matches how people share on TikTok, Reels, and Shorts.

The trade-off is obvious, and I put it on the page instead of hiding it: videos are 15 seconds, there is no custom song upload yet, and it is built for two adult performers.

2. The model: Seedance 2.0

Videos are generated with Seedance 2.0, ByteDance's multimodal audio-video model. Two properties made it a good fit for this product:

It generates video and audio together. For a rap clip, the beat, the vocal, and the performance come out of one pass, so the mouth movement is produced alongside the sound instead of being glued on afterwards.
It accepts reference images. The user's portraits act as identity references (face, outfit, hair), and the stage supplies everything else.

According to the provider docs I used, clip length goes up to 15 seconds, which is exactly the length I wanted, and a single request can combine a text prompt with several reference images. Check the docs of whichever provider you call it through, since limits and parameters can differ.

3. Prompts as structured templates

My first prompts were a paragraph of prose per scene. They produced inconsistent results, and when something went wrong I could not tell which sentence caused it.

The fix was to split every scene prompt into five labelled blocks:

[Scene]        identity + environment + camera setup
[Music]        genre, tempo, instruments, vocal requirements
[Timeline]     a second-by-second action script
[Lyrics]       the exact lines to perform
[Constraints]  hard rules and a list of things that must NOT happen

A simplified example for a rooftop stage:

[Scene]
Use reference image 1 for the single rapper's identity, outfit, hair,
and proportions. On the rooftop terrace, keep the performer centered in
a locked-off knee-up vertical 9:16 shot. Preserve the city skyline,
string lights, palms, lounge furniture, and reflective stone floor;
no other people enter.

[Music]
Confident melodic rap, 110 BPM: hard kick, snare, rolling hats, deep sub
bass, piano-and-bell hook, airy pads. One clear vocal rides a constant
radio-loud beat.

[Timeline]
0-3s: bounce on beat and point at camera. 3-6s: broad arm sweeps.
6-9s: lean in with a smile and head bob. 9-12s: step side to side,
hands wide. 12-15s: keep the energy high and freeze on the final hit.

[Lyrics, in English, perform exactly these]
1. ...
(six lines)

[Constraints]
Accurate lip-sync, one rapper only, no subtitles or text, no cuts, no
camera move, no extra people. Keep the performer in the lower three
quarters, knee-up, with hands below the top quarter.

Why this structure works for me:

Scene: lock identity first, then framing. Saying which reference image controls identity, and fixing the shot as locked-off and knee-up, removes a lot of variation. Waist-up framing is also kinder to faces, hands, and lip sync than full-body shots.

Music: translate "vibe" into parameters. "A cool rap beat" does very little. A fixed tempo, a named instrument list, and "one clear vocal" give the model something concrete, and they let me plan the lyrics against a known rhythm.

Timeline: one action per segment. Splitting 15 seconds into five 3-second beats, each with one main movement, gives the clip visual variety and a clear ending ("freeze on the final hit") so it feels finished instead of cut off.

Lyrics: short on purpose. Six lines of roughly 7 to 10 syllables fit in 15 seconds. Longer lines are where lip sync drifts. Telling the model to perform the lines exactly also reduces rewrites.

Constraints: one rule per failure mode. This is the block that grew the most. Typical image-to-video problems and the rule I added for each:

Failure mode	Constraint
Lip sync drifting	`Accurate lip-sync`, shorter lines
Extra people appearing	`one rapper only`, `no extra people`
Garbled text on signs or captions	`no subtitles or text`
Face changing after a cut or camera move	`no cuts, no camera move`
Hands deformed or cropped at the top of frame	`hands below the top quarter`
Framing hidden by app UI overlays	`lower three quarters, knee-up`

The takeaway: a longer prompt is not a better prompt. Saying clearly what should happen and what must not happen is what moved quality, and having separate blocks means I can change one thing at a time and see what it did.

4. Treat generations like payments

Every generation costs real money, and some will fail. If a user pays and gets a broken video, trust is gone. So I treat credits like a small payments system. Three rules:

Hold credits before doing the work. Never call the model first and charge afterwards.
Record every change in an append-only ledger with an idempotency key.
Refund on terminal failure, at most once.

A simplified schema:

CREATE TABLE credit_ledger (
  id         BIGSERIAL PRIMARY KEY,
  user_id    BIGINT NOT NULL,
  delta      INT    NOT NULL,                -- negative = spend, positive = grant/refund
  kind       TEXT   NOT NULL CHECK (kind IN ('purchase','hold','refund')),
  job_id     BIGINT,
  idem_key   TEXT   NOT NULL UNIQUE,         -- one business action, one row
  created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

CREATE TABLE credit_balance (
  user_id BIGINT PRIMARY KEY,
  balance INT NOT NULL CHECK (balance >= 0)  -- last line of defense
);

Creating a job and holding credits happen in one transaction. The conditional update makes the balance check and the deduction a single atomic statement:

const dec = await tx.query(
  `UPDATE credit_balance SET balance = balance - $2
   WHERE user_id = $1 AND balance >= $2
   RETURNING balance`,
  [userId, cost]
);
if (dec.rowCount === 0) throw new Error("INSUFFICIENT_CREDITS");

const job = await tx.query(
  `INSERT INTO jobs (user_id, scene_key, status, cost_credits)
   VALUES ($1, $2, 'created', $3) RETURNING id`,
  [userId, sceneKey, cost]
);

await tx.query(
  `INSERT INTO credit_ledger (user_id, delta, kind, job_id, idem_key)
   VALUES ($1, $2, 'hold', $3, $4)`,
  [userId, -cost, job.rows[0].id, `hold:job:${job.rows[0].id}`]
);

The refund path has two guards. First, the job status moves to failed only from a non-terminal state (a compare-and-set). Second, the ledger insert uses ON CONFLICT DO NOTHING, and the balance is only increased if a row was actually inserted:

const upd = await tx.query(
  `UPDATE jobs SET status = 'failed', error_code = $2, finished_at = now()
   WHERE id = $1 AND status NOT IN ('succeeded','failed')
   RETURNING user_id, cost_credits`,
  [jobId, errorCode]
);
if (upd.rowCount === 0) return; // already in a terminal state

const ins = await tx.query(
  `INSERT INTO credit_ledger (user_id, delta, kind, job_id, idem_key)
   VALUES ($1, $2, 'refund', $3, $4)
   ON CONFLICT (idem_key) DO NOTHING RETURNING id`,
  [upd.rows[0].user_id, upd.rows[0].cost_credits, jobId, `refund:job:${jobId}`]
);

if (ins.rowCount === 1) {
  await tx.query(
    `UPDATE credit_balance SET balance = balance + $2 WHERE user_id = $1`,
    [upd.rows[0].user_id, upd.rows[0].cost_credits]
  );
}

Duplicate callbacks, worker restarts, and manual retries can all hit this code path, and the user still gets exactly one refund. A nightly query comparing each balance against the sum of its ledger rows catches anything that slips through.

Retries are not new jobs

Failures fall into two groups. Timeouts, upstream 5xx errors, and rate limits are worth retrying with backoff. Rejected inputs and moderation failures are not. Retries reuse the original hold, so a user is never charged twice for one video.

5. Consent and privacy are product features

The tool works with real faces, so the rules are part of the product, not a footnote:

Everyone shown must be you or an adult who agreed to take part.
Images of minors and public figures are not accepted.
Sexual, hateful, deceptive, or harassing content is not allowed.
Outputs are labeled as AI-generated.
Uploaded photos are deleted after seven days.

I would rather lose some "make a video of a celebrity" traffic than build something that is awkward to defend. Retention promises like "deleted after seven days" are also easy to forget operationally, so I treat them as a system mechanism (storage lifecycle rules plus a database flag), not as a manual chore.

What it can't do yet

Videos are 15 seconds.
No custom song upload.
Two adult performers only.
It is AI, so likeness to the photos varies.

Credits are 10 per video, packs start at $6.99, there is no subscription, and failed renders are refunded automatically.

What I'd like feedback on

Which stage or scene would you want next?
If you have built on a video model: what other failure modes should I be writing constraints for?
Does the credit pricing feel fair?

You can browse every stage for free at airapgenerators.com. If you try it, I would love to hear where it breaks.

How to Write Prompts for Midjourney, DALL-E, Stable Diffusion, and Flux (They're Not the Same)

Jason Wei — Fri, 11 Sep 2026 07:51:00 +0000

Copy the same prompt into four different image models and you'll get four very different results. That's not random — each of these models was trained differently, optimizes for different things, and "reads" prompts differently. Here's a breakdown of the major players in 2026 and how to actually write for each one.

Midjourney — aesthetics-first, less is often more

Midjourney (currently on V7/V8) is built around one goal: the best-looking result from the least input. It has strong built-in aesthetic defaults, so short, simple prompts often outperform long, over-specified ones.

Prompting tips:

Subject + style + mood is usually enough — you don't need to over-describe
Parameters (aspect ratio, stylization strength) do more work than extra adjectives
Weak spot: text rendering and fine-grained control. If you need accurate in-image text, look elsewhere
DALL-E / GPT Image — strongest instruction-following

The model behind ChatGPT's image generation (now branded GPT Image) prioritizes following your instructions precisely over free creative interpretation. The more specific and structured your description, the closer the output matches your intent.

Prompting tips:

Longer, more explicit prompts work well here — object counts, spatial relationships, exact text content
Strong content-safety filtering makes it a safer default for brand/enterprise use
Won't necessarily produce the most "striking" image, but it's the most controllable
Stable Diffusion — maximum freedom, maximum prompt dependency

Stable Diffusion (now at 3.5/4) is open-weight, locally deployable, and pairs with tools like ControlNet for precise control. The tradeoff: it has weaker built-in aesthetic defaults than Midjourney, so output quality depends much more heavily on how well you write the prompt.

Prompting tips:

Be explicit about style keywords ("cinematic lighting," "oil painting," "35mm film") rather than relying on the model to infer style
Negative prompts matter a lot here — excluding unwanted elements is often more effective than adding more positive description
Best fit for teams that need batch generation, LoRA fine-tuning, or zero marginal cost via self-hosting
Flux — the open-weight model built for prompt accuracy

Flux (from Black Forest Labs) sits between Midjourney's "just works" simplicity and Stable Diffusion's full control — it's known for high prompt adherence, multi-reference input support, and strong realism in lighting and materials.

Prompting tips:

High adherence means detail actually matters — it's worth being specific
Good fit for maintaining consistent characters or brand visuals across a series of generations via LoRA
Ideogram — the specialist for in-image text

If your use case involves generating readable, accurate text inside the image itself (posters, logos, marketing assets), Ideogram is the clear specialist — most general-purpose models still struggle here.

What's actually universal across all of them

Despite the differences, a few rules hold everywhere:

Structured beats prose — subject, style, lighting, composition, mood as short comma-separated attributes usually outperforms a paragraph of description
Specific beats vague — "studio lighting, 35mm film" beats "nice lighting"
Negative prompts matter, especially on more controllable models like Stable Diffusion
A prompt tuned for one model rarely transfers cleanly to another — you generally need to adapt it, not copy-paste it
A practical starting point

If you're starting from a reference image rather than a blank prompt box, it helps to extract a baseline structured prompt first, then adapt it per target model — adding style tags and negative prompts for Stable Diffusion, or expanding detail for DALL-E.

I've been using Findimageprompt.com for the extraction step (Image to Prompt) and then hand-tuning from there — it's faster than writing from scratch every time. It also has Text to Prompt (expand a rough idea into a detailed prompt), an AI Image Describer (check whether a result matches intent), and a built-in AI Image Generator, so the extract → adjust → generate → verify loop can happen in one place.

Bottom line

There's no universally "best" model — Midjourney for aesthetics with minimal effort, DALL-E/GPT Image for precise control and enterprise safety, Stable Diffusion for full freedom and local deployment, Flux for high adherence and consistency, Ideogram for text-heavy designs. The prompting principles carry over, but the specifics don't — write for the model you're actually using.

I Built a Tool to Reverse-Engineer AI Prompts From Images — Here's What I Learned

Jason Wei — Fri, 21 Aug 2026 14:40:21 +0000

A few months back I kept running into the same annoying loop: I'd see an AI-generated image with a style or lighting I loved, and have zero idea what prompt would get me something similar. Object-tagging tools weren't the answer — they'd give me "person, outdoor, tree" and completely miss the stuff that actually makes an image distinctive: lighting, color grading, art medium, mood.

So I built Findimageprompt.com to solve that specific problem. Here's a quick rundown of what it does and some of the things I learned building it.

The core insight: captioning ≠ prompting

Early on I assumed a good image captioning model would be enough. It's not. Captioning answers "what is this image?" Prompting needs to answer "what would I type to generate something like this?" Those are different tasks, and the second one requires pulling out attributes a normal caption throws away — lighting direction, composition, camera angle, artistic style.

Output format matters more than I expected

This was the biggest surprise: a technically accurate, well-written description is often a worse prompt than a rougher, structured one. Generators like Midjourney and Stable Diffusion respond much better to short, comma-separated attributes than to flowing prose. So a meaningful chunk of the work isn't just generating a description — it's reformatting that description into the attribute-list shape these models are actually trained on.

Four tools, one shared engine

Rather than shipping a single "image to prompt" feature, I built it as a loop:

Image to Prompt – image in, structured prompt out
Text to Prompt – rough idea in, detailed prompt out
AI Image Describer – plain-language description, for checking generation results against intent
AI Image Generator – generate directly from any prompt without leaving the site

The reason for building it this way: reverse-engineering a prompt is rarely a one-shot task. You pull a prompt, generate, compare, and adjust. Having all four tools share the same underlying engine made that iteration loop actually usable instead of copy-pasting between four separate sites.

Keeping it frictionless

No signup, no API keys, runs in the browser. For a tool people are going to try on a whim with one image, every bit of setup friction is a reason to bounce before they see if it's useful.

Where it's at now

It's live and free to use. I'm currently working through pricing/payment setup and a broader promo push (Product Hunt launch coming up), so feedback on prompt quality — especially cases where the output clearly missed the mark — is genuinely useful to me right now.

If you work with AI image generation and want to try reverse-engineering a prompt from a reference image, it's here: https://findimageprompt.com/

Happy to answer questions about the multimodal/prompt-formatting side of it in the comments.