DEV Community: CodeByAby

Prompting Tips for Turning a Photo Into an AI Doll or Boxed Action Figure

CodeByAby — Mon, 19 Oct 2026 17:32:48 +0000

The "me as a boxed action figure" trend is a fun way to see how image models handle identity, packaging and style transfer at the same time. I spent some time with AI Doll Generator, a browser tool that turns one face photo (or a text prompt) into a collectible-style doll, and these are the practical notes I'd give anyone trying it.

What the tool offers

According to the site, it's free to try and needs no sign-up. You get two modes:

Photo Mode: upload a JPG/PNG face photo.
Text Mode: describe the doll you want.

Nine style presets are listed: Barbie, Action Figure, Anime, Chibi, Gothic, 3D Pop, BJD, Pixel Art and Labubu. There's also a Clean Base vs Packaged toggle and a Resemblance slider.

Input photo tips

Frontal face, even light. The site itself recommends this, and it matters more than anything else.
No sunglasses or heavy filters. Occluded eyes make the likeness drift.
Plain background. Less noise for the model to reinterpret.

Style tips

Want the retail-box look? Choose Action Figure + Packaged.
For avatars, Anime or Chibi with a clean base tends to read better at small sizes.
Pixel Art is a nice option for game-style profile pictures.
Raise Resemblance if the result looks like a stranger; lower it if you want a more stylized toy.

If you prefer prompts

Text Mode lets you skip the photo entirely. The site keeps a list of starting points in its best AI doll prompts post, and a step-by-step photo to action figure guide.

A note on consent

Only upload photos of yourself or people who agreed. It's a toy, but it's still someone's face.

Behind the Trend: Why AI Zombie Love Story Videos Are Everywhere (and How Photo-to-Video AI Works)

CodeByAby — Thu, 15 Oct 2026 02:02:17 +0000

A developer-friendly look at the viral zombie romance format, the pipeline behind photo-to-video generation, and the product decisions that make these tools usable.

Every few months a new AI video format takes over social feeds. This autumn it has been the zombie love story: a short, cinematic clip where one partner has turned into a zombie and the other chooses to stay anyway. It is a strange mix of horror and romance, and it is a good case study in why some AI formats spread and others don't.

This post covers two things: why this particular format works, and what is happening under the hood when a tool turns a still photo into a short story video. No benchmark numbers here, just the architecture and the reasoning.

Where the format came from

The version most people recreate is "CHOICE," a short AI film posted on Instagram in mid-September 2026 by filmmaker Aytech Ashkhamakhov (@techmaf). A man finds the woman he loves after she has turned; instead of fighting, he opens his arms, and as she lunges the film cuts to memories of their life together. Plenty of commenters said they thought it was a scene from a real movie.

After that, tutorials, templates and dedicated tools showed up so people could star in their own versions.

Why it spreads

From a product perspective, a few properties make this format unusually shareable:

Personalization is the payload. The story is the same every time; the faces change. That is the ideal shape for a generator: fixed structure, variable input.
A clear three-beat story. The Turn, The Choice, The Hug. Short enough to fit a 15-second clip, structured enough to feel like a narrative.
Emotion over spectacle. It is a love story wearing a horror costume, which makes it shareable with a wider audience than gore would.
Built-in social loop. You make it with a partner, so you tag the partner, and their friends see it.

Developers building generative products can learn a lot here: templates with strong narrative structure tend to beat open-ended "type any prompt" interfaces for mainstream users.

How photo-to-video works, at a high level

Implementations differ, but most photo-to-video story pipelines look roughly like this:

1. Input validation and face handling

The user uploads either one photo with two people or two solo photos. The system needs to detect faces, check they are usable (not too small, not blurred, not occluded), and figure out which identity is which. Rejecting bad input early saves compute and saves the user from a disappointing result.

2. Image editing for the transformation

One identity gets transformed into a zombie version while keeping recognizable features: face shape, hairline, overall likeness. This is usually an instruction-guided image editing model. The hard part is the balance: transform too little and there is no "Turn"; transform too much and the person is unrecognizable, which kills the emotional payoff.

3. Keyframes per story beat

Rather than generating a whole video from scratch, many pipelines create a reference image per scene. For a three-beat story, that might mean one keyframe for the turn, one for the recognition and choice, and one for the hug.

4. Image-to-video generation per segment

Each keyframe is animated by an image-to-video model with a scene-specific prompt describing motion, camera, and mood. Generating per segment is easier to control than one long generation, and it means a single failed segment can be retried without redoing everything.

5. Stitching and audio

Segments are concatenated, and audio is added. For this format, sound effects and ambience (no dialogue) fit best; dialogue would require lip sync and would fight the cinematic tone.

6. Delivery

The final clip is stored and delivered to the user, often with a private share link.

Product decisions that matter

A few engineering-meets-product lessons from this kind of tool:

Preview cheaply before generating expensively. Video generation is the costly step. Showing a still image preview first lets users check the transformation on their face before committing. On ZombieLoveVideo, for example, the free preview is a watermarked zombie photo rather than a video, behind a Google or email sign-in with no card needed. That keeps the free tier useful without burning video compute on every visitor.

Constrain the story. Fixed beats mean consistent quality. Prompt engineering happens once, by the builder, not every time by the user.

Design for failure. Generative APIs fail sometimes. Segment-level retries and clear error handling matter more than people expect.

Handle photos responsibly. Users upload faces. Keep retention short, keep share links private by default, and make deletion easy.

Takeaways

The zombie love story trend isn't really about zombies. It is about a fixed emotional structure plus personal faces, delivered in a format short enough to watch twice. For developers, it is a reminder that the most successful generative products often hide the model behind a strong template.

If you want to see the pipeline's output from the user side, you can try a free preview at zombielovevideo.com.

I built a fact-checked meme explainer site with Next.js static export (and structured data for LLMs)

CodeByAby — Fri, 09 Oct 2026 13:17:21 +0000

When a meme goes viral, the search intent is simple: what is this, where is it from, is it real? That’s an ideal case for a small static reference site. I built one for the Rumpelstiltskin AI meme, and here’s the setup.

Stack: Next.js 15 App Router with output: "export", plain CSS, no database, deployed as static files.

Page contract (one topic per page):

A short answer band at the top, so the verdict is the first thing a crawler or an LLM reads.
A facts list (

) with explicit “not disclosed” values instead of guesses.
Sections, FAQ, and a sources block.

Structured data: every page ships FAQPage and BreadcrumbList JSON-LD plus an article schema, generated from the same data that renders the visible FAQ so the two never drift.

Meta consistency: a single pageMeta() helper sets canonical, OG and Twitter tags, and pages can’t ship without it.

Citations as data: each fact maps to an entry in a SOURCES list, and off-site links go through one ExternalLink component (new tab, rel="noopener", no noreferrer, so cited sites can see the referrer).

Live example, the Rumpelstiltskin meme explained, with a timeline page that sets sources side by side where they disagree.

Happy to share the pageMeta() and JSON-LD components if useful. What do you use for keeping structured data in sync with visible content?