DEV Community: Manoranjan Xuseen

Users Care More About “Still Looks Like Us” Than Visual Spectacle

Manoranjan Xuseen — Fri, 03 Jul 2026 02:30:26 +0000

Recommended tags: ai user-experience product image-generation

When people evaluate generative photo tools, builders often focus on visual wow factor first.

Big atmosphere. Dramatic lighting. Beautiful scenery. Strong cinematic mood.

But for couple-photo use cases, that is not actually the first question users ask.

The first question is much simpler: “Do we still look like us?”

If the answer is no, the rest barely matters.

That changes the product priority stack. A visually impressive image with weak identity preservation is not a near miss. For many users, it is a total failure. They are not buying an abstract artwork. They are trying to create something emotionally personal.

This also explains why flashy demo outputs can be misleading. Spectacle is easy to notice. Identity drift is easy to forgive when the subjects are strangers. But real users are extremely sensitive to tiny deviations in their own face, posture, and overall vibe.

So the quality bar is not “How cinematic is this image?” It is closer to:

do both people still feel recognizable
does the scene feel plausible for them
would they actually want to share or print it

That is a more grounded evaluation framework, and it leads to different product choices. You become less interested in extreme styles and more interested in consistency, restraint, and trust.

I think this is one of the most useful mindset shifts in consumer AI image products. People do not always want the most generative result. Often they want the most believable one.

That principle is central to AI Couple Photo: visual polish matters, but only after the photo still feels like it belongs to the two people who uploaded it.

Templates Should Set Expectations, Not Drive the Output

Manoranjan Xuseen — Mon, 29 Jun 2026 05:54:53 +0000

Many AI image tools use template images in a way that quietly confuses users.

The template looks amazing, so people assume the product will somehow transplant that exact composition onto their own photos. When the output is merely “inspired by” the example, trust drops.

We wanted to avoid that.

For an AI couple photo product, templates are useful, but mostly as expectation-setting devices. They show what kind of scene, mood, and framing the user is choosing. They should not imply that the template itself is the source material.

That distinction matters because our goal is not to paste two faces into a pre-made picture. The goal is to generate a new couple photo that still preserves the identity of the two users.

If a template is treated like a hidden base image, users get the wrong mental model:

they expect exact poses instead of approximate composition
they expect the model to copy visual details that should not be copied
they become more likely to judge natural variation as product failure

So I prefer a cleaner contract: templates are references, not ingredients.

Product-wise, that leads to a better interaction. Users choose a direction, not a promise the system cannot literally keep. The model gets room to adapt to their inputs, while the user still knows what kind of result they are steering toward.

That is a subtle UX decision, but I think it matters a lot in generative products. Good examples should narrow ambiguity, not create a fake sense of determinism.

That is how we think about templates in AI Couple Photo: they are there to help users choose, not to trick them into believing a hidden face-swap pipeline exists underneath.

Combining Two Solo Portraits Is a Product Problem, Not Just a Model Problem

Manoranjan Xuseen — Fri, 26 Jun 2026 11:53:41 +0000

Combining Two Solo Portraits Is a Product Problem, Not Just a Model Problem

When people look at an AI couple photo generator, the first instinct is to frame it as a model problem.

Can the model generate attractive people? Can it handle style transfer? Can it make a cinematic background?

Those questions matter, but they are not the main problem.

The real difficulty starts earlier. Two source photos usually come with different lighting, different crop ratios, different camera distance, different head angles, and different levels of image quality. Even if the underlying model is strong, the final output still fails if the product does not help manage those mismatches.

That is why I think this category is fundamentally a product problem as much as a model one.

You need product decisions around:

what kinds of inputs should be accepted or discouraged
how much scene freedom is realistic for a given pair of photos
when to guide users toward safer templates or scenarios
how to communicate likely failure cases before generation

If you ignore those layers and rely only on the model, the experience becomes inconsistent. Some generations look great in a demo. Real user photos do not.

The job of the product is to reduce bad combinations before the generation step, not just hope the model rescues everything afterward.

That shift in thinking changed how we look at this space. We are not only building an image generator. We are building a system that helps two unrelated inputs become one emotionally believable output.

That is the lens behind AI Couple Photo, and I think more generative products would benefit from treating input orchestration as first-class product work rather than invisible preprocessing.

Why We Didn't Make Prompting the Core UX of an AI Couple Photo Generator

Manoranjan Xuseen — Sun, 21 Jun 2026 12:51:27 +0000

Why We Didn't Make Prompting the Core UX of an AI Couple Photo Generator

Recommended tags: ai ux product image-generation

A lot of AI products default to the same interaction: give people a big prompt box and let them figure it out.

We deliberately did not do that for our couple photo product.

The reason is simple. People do not come to an AI couple photo tool because they want to experiment with wording. They come because they want to turn two solo photos into one believable shared photo. That is a very different job.

In this workflow, prompt text can describe style, but it does not reliably solve the hardest parts:

whether both people still look like themselves
whether two mismatched source photos can be merged naturally
whether pose, spacing, and eye line feel like a real photo
whether the result looks like a memory instead of a collage

If prompt becomes the main control, users end up doing failure recovery for the system. The photo looks wrong, so they type more. Identity is off, so they type more. The scene feels fake, so they type more again. That may look flexible on paper, but in practice it just pushes model uncertainty onto the user.

We found that structured choices work better for this kind of task. Let people choose a scene, a style, and a composition direction first. If they want, they can add one extra preference later. That keeps the interaction expressive without making every user behave like a prompt engineer.

For products like this, the real question is not “How much control can we expose?” It is “How much uncertainty can we remove before the user even has to think about it?”

That is the product direction we are taking with AI Couple Photo: prompt can exist, but it should be a secondary control, not the main interface.

Building an AI couple photo generator from two solo portraits

Manoranjan Xuseen — Tue, 16 Jun 2026 12:05:46 +0000

Full disclosure: I am building AI Couple Photo, an online AI couple photo generator.

The problem

A lot of couples want one good photo together, but only have separate portraits. Distance, schedules, missed trips, and special occasions make that surprisingly common.

What I wanted the product to do

I wanted a workflow that feels simple for normal users, not like a prompt-engineering exercise.

With AI Couple Photo, the user:

Uploads one clear adult portrait for each person.
Picks a style such as wedding, date, studio, outdoor, retro, winter, fashion, anime, or motorcycle.
Generates one shared portrait in the browser.

Product decisions that mattered

No prompt writing required
Style-first flow instead of blank-text prompting
Private, browser-based usage
Support for JPG, PNG, and WEBP uploads
Multiple output styles for different couple-photo use cases

Good use cases

Long-distance couples who do not already have a good photo together
Anniversary or birthday keepsakes
Wedding-style portraits without booking a photographer
Romantic profile photos and lightweight creator visuals

What I learned

People respond better to a concrete, guided workflow than to a generic image generator when the goal is emotional and personal. The biggest UX win was reducing choices to a few meaningful steps instead of exposing every possible knob.

If you want to try it, the product is here: AI Couple Photo.

Building a browser-based AI object remover for fast photo cleanup

Manoranjan Xuseen — Fri, 29 May 2026 01:03:26 +0000

I kept seeing the same image-cleanup problem in product workflows: someone only wants to remove one distracting object, but the editing flow is still too heavy.

That is why I split our object-removal workflow into a dedicated page instead of hiding it behind a generic homepage.

What the tool focuses on

PicTextRemover Object Remover is built for one specific job: remove an unwanted object, person, prop, defect, or clutter area from a photo after the user marks the target with a brush mask.

The page is here:
https://pictextremover.com/object-remover?utm_source=devto

Why brush masks matter

A lot of AI image cleanup tools guess too much. That is fine for quick experiments, but not great when the rest of the image must stay stable.

The brush-mask flow is more predictable because the user defines exactly what should disappear. That helps when working with:

ecommerce product photos
real estate images
social media creatives
presentation screenshots
everyday personal photos

Current workflow

Upload a JPG, PNG, or WebP image.
Brush over the object or area that should disappear.
Let the model rebuild the hidden background.
Download the cleaned image.

What I am still improving

I am especially interested in failure cases where:

the removed object is close to text or logos that must stay
the background has repeating patterns
the scene has perspective lines or shadows
the target is small but visually important

If you build image tools, internal creator workflows, or listing pipelines, I would like to know which edge cases usually break your cleanup stack.

How I clean captions and labels from images without Photoshop

Manoranjan Xuseen — Fri, 22 May 2026 06:04:02 +0000

Why this workflow works

If the real job is just removing a caption, label, poster headline, or screenshot text, opening Photoshop is usually overkill.

What matters more is whether the background still looks usable after the text is gone. Many tools technically remove the words, but leave blur, smears, or obvious patching behind.

The simple workflow

Upload the image.
Brush only when you need precise control.
Let the tool reconstruct the nearby texture and lighting.
Export as soon as the result already looks natural.

Where this is useful

This works especially well for:

product photos
screenshots
poster updates
slide assets

What I use

I have been using PicTextRemover for this kind of task because it keeps the surrounding area cleaner than most quick-fix tools I tested.

It is free to try, and the result is usually good enough for everyday production work when the goal is clean text removal rather than full retouching.

Bottom line

The real time saver is not just AI removal. It is avoiding a whole editing stack for small cleanup jobs.

Why every AI lyrics generator writes the same chorus

Manoranjan Xuseen — Thu, 30 Apr 2026 04:43:22 +0000

Anyone who has spent time generating lyrics with AI tools has run into the same problem. Whether you use GPT, Claude, Gemini, or Suno's lyric model, the output keeps reaching for the same vocabulary: shadows, echoes, neon, fire, flames, dust, ashes, broken, phoenix. Different tools, same words.

This comes up constantly in r/SunoAI and other songwriting communities. A few quotes that show up week after week:

"I've tried the big three and all three of them just produce the same lines."

"I end up changing about 98% of it nearly every time."

"It likes lyrics for how they look on the page, which is not how lyrics work."

The pattern: people use AI to draft lyrics, get something that looks fine on the screen but feels generic when sung, and end up rewriting most of it. For casual users that wastes time. For songwriters who actually care about voice and imagery, it kills the workflow.

Where it goes wrong

Three problems show up over and over in AI-generated lyrics, and they're worth naming separately because they each need a different kind of fix.

The vocabulary collapses to a small set. Asking for "no clichés" in the prompt buys you one generation. After that, the model starts reaching for the next-closest cliché — silhouettes for shadows, embers for fire, whispers for echoes. The vocabulary shifts an inch but doesn't really change.

Sections stop doing their jobs. A verse should set a scene. A hook should land a single phrase that survives being repeated four times. A bridge should change something — perspective, time, speaker. Most AI lyric output gives you four stanzas of the same emotional temperature, all doing the same emotional work.

Vague prompts produce vague output. "A breakup song" or "trap song about heartbreak" doesn't anchor the model against anything specific. The cliché tokens are the path of least resistance, so that's what you get.

How SongLyricsLab handles it

SongLyricsLab doesn't take a single prompt and hand it to a model. It walks you through five steps, and each step targets one of the failure modes above:

Understanding your idea
Sketching directions for your song
Writing the chorus hook
Drafting verses with concrete images
Removing AI clichés and tightening lines

Steps 1 and 2: from a feeling to a direction

Most people don't sit down to write a song with a fully-formed scene in their head. They have a feeling, a half-memory, a phrase they can't shake, an unresolved conversation. Turning that into a prompt that an AI can actually use feels like extra writing — which is the opposite of why they came to a generator.

The first two steps are designed for that gap.

Step 1 takes whatever seed you have — a fragment, a feeling, a sentence — and asks a few targeted questions to flesh it out. Where is this happening? Who is in it? What just changed? What hasn't been said yet? Nothing is mandatory. The more you fill in, the more specific the draft can be.

Step 2 sketches a few directions the song could take from there. If your seed is "regret about a relationship," the same situation can land on resolution, on stuck-ness, on quiet acceptance, on anger. You pick one and the prompt for the rest of the flow is shaped accordingly. If you don't know which one you want, picking one and seeing where it goes is faster than staring at a blank input field.

Steps 3 and 4: each section is written separately

Once the direction is set, the hook and the verses get generated as separate calls, with different instructions for each.

The hook prompt asks for a single repeatable phrase that pays off the setup. One line, not a paragraph. A claim that survives being repeated four times in a row.

The verse prompt asks for a concrete scene with at least one specific noun. Not "the night" — a specific room, a specific object, a specific moment. The verse plants something the hook can land on, instead of restating the same emotion in different words.

This is what's missing when you ask a model to "write a song about X" all at once. The model has no functional pressure on each section, so all four stanzas come out doing the same job. Splitting the call gives each section its own purpose.

Step 5: the polish pass

After the draft is generated, the last step takes another pass to clean up. It looks for the cliché vocabulary that AI lyric output tends to fall back on, and rewrites those lines. It tightens phrasing where the model padded — adjective stacks, throwaway connectors, the kind of filler that reads fine on the page but doesn't sing.

The polish pass isn't doing anything fancy. It's there because even with good per-section prompts, the model will sometimes default to shadows anyway, and it's cheaper to clean the output than to keep regenerating.

If you want to see the whole flow end-to-end, songlyricslab.com is the live version. No signup.

Why AI-Generated Videos Look Disjointed (and the Claude Code Skill I Built to Fix It)

Manoranjan Xuseen — Thu, 09 Apr 2026 15:00:45 +0000

The Problem Nobody Talks About

If you've used any AI video generator in the last year — Sora, Veo, Kling, Runway, Luma, Seedance, Wan, pick your poison — you've probably run into the same wall:

You can make one beautiful 5-second clip. But you can't make a 30-second video that doesn't look like garbage.

The individual shots are stunning. The cinematography is often better than amateur footage shot on a phone. The lighting is usually dreamlike. And then you try to make an actual TikTok or ad or explainer, and you end up with this:

Shot 1: warm golden hour, shallow DOF, gorgeous
Shot 2: suddenly clinical daylight, deep focus, different lens entirely
Shot 3: back to cinematic, but a completely different color palette
Shot 4: looks like it was shot on a different planet
Final video: jarring cuts that scream "this was made by six different cameras on six different days"

The tools aren't the problem. The tools can produce world-class shots. The problem is that you're treating each generation as an independent creative decision instead of part of a coordinated shoot.

I spent way too long fighting this and eventually built a Claude Code skill to fix it. This post is about what I learned — the conceptual insight, the technical approach, and a walkthrough you can steal.

The Core Insight: Visual Consistency > Shot Quality

Here's the counterintuitive thing: a mediocre but consistent set of shots edits together. Six gorgeous but mismatched shots do not.

If you've ever worked with a real cinematographer, this is obvious. Before the camera rolls on day one, they lock in:

Color palette
Key lighting direction and temperature
Lens choice (prime vs zoom, focal length, max aperture)
Film stock (or digital LUT) for the "look"
Camera movement grammar (handheld vs locked vs crane)

Every shot in the project respects that baseline. That's how 100 clips cut together feel like one intentional movie. It's not about any single shot being perfect. It's about every shot belonging to the same world.

AI video generators give you zero enforcement of this. Every prompt is a clean slate. If you don't encode the baseline into every prompt, you get six different movies in a 30-second timeline.

Why Single-Prompt Optimizers Don't Help

The AI space is already crowded with "prompt optimizer" tools for video. They take your vague idea and spit out a more detailed single prompt. Useful if you're making one clip. Useless if you're making six.

A prompt optimizer can turn "horse running" into:

A majestic horse galloping across a sun-drenched meadow, golden hour backlight with warm rim light, shallow depth of field, slow motion, cinematic 1080p, 16:9

That's a fine prompt. But if your video needs 6 shots and you optimize each one independently, you'll get 6 different "optimal" prompts with 6 different visual languages. Each one is individually optimized and collectively broken.

What's missing isn't better per-shot prompting. It's a layer above the prompts — a shared visual grammar that every shot has to respect.

The Approach: A Shot-List Storyboard

The skill I built does exactly one thing: it turns a brief into a coordinated shot-list storyboard.

Here's the workflow:

Step 1 — Brief Intake

The skill asks for five things:

Platform and duration (TikTok 30s, Reel 15-60s, YouTube Short, ad, explainer)
What the video is about
Brand vibe (cozy, energetic, premium, minimalist, playful, cinematic)
Call to action
Hard constraints (logo, colors, locations)

Five questions, one message. No multi-turn interrogation.

Step 2 — Infer Structure

Duration → shot count, based on platform conventions:

Platform	Duration	Shots	Pacing
TikTok Hook	15s	3	Fast cuts, single idea
TikTok Reel	30s	6	Hook → Build → Payoff → CTA
Instagram Ad	30s	6	Hook → Problem → Product → Benefit → Proof → CTA
YouTube Short	60s	12	Hook → 3-act structure → CTA
Product Explainer	90s	18	Problem → Solution → How it works → Results → CTA

Five seconds per shot is the sweet spot: long enough to land an idea, short enough to match the average scroll-dwell time on TikTok and Reels.

Step 3 — The Visual Theme Layer (The Important Part)

Before writing a single shot, the skill locks in a shared visual language. This is the layer that makes everything work:

## Visual Theme (applied to every shot)

- Color palette: Deep espresso brown #3B2416, cream #F5E6D3,
  muted amber #D4A574, soft sage green #8FA88C
- Lighting: Warm golden backlight with motivated window light,
  soft shadows, no harsh fluorescents
- Lens: Shallow DOF, gentle bokeh, 35mm full-frame look
- Film: Subtle 16mm grain, slightly muted saturation,
  warm 3200K color temperature
- Motion: Locked-off or very slow push-ins, no handheld shake

Every subsequent prompt must reference these values. Not "warm lighting" in the abstract — "warm golden backlight with motivated window light at 3200K color temperature, shallow DOF, 35mm full-frame look, subtle 16mm film grain." The consistency is enforced through repetition.

This feels verbose when you look at a single prompt, but it's exactly how you get six independently generated clips to look like they came from the same shoot.

Step 4 — Write Each Shot

Every shot gets this structure:

## Shot N (START-ENDs) — [Purpose: Hook/Setting/Human/Detail/CTA]

Composition: [shot type + angle, e.g., "Extreme close-up, overhead"]
Camera move: [locked/slow dolly in/tracking/crane up]
Lighting:    [from Visual Theme, applied to this scene]
Subject:     [what is in frame]
Action:      [what is happening]

Prompt to copy:
> [40-80 word cinematic prompt including all visual theme values,
>  ending with "cinematic 1080p, synchronized audio, Ns, [aspect]"]

Audio direction: [ambient/music beat/voice-over line]

The critical rules:

Every prompt repeats the shared visual language — palette, lighting, lens, film look
Be concrete — "a woman" → "a barista in her late 20s with wavy auburn hair, denim apron"
Use cinematography vocabulary — ECU, CU, MS, WS, OTS, dolly, crane, tracking, rack focus
Always end with technical spec — duration, aspect ratio, "cinematic 1080p, synchronized audio"

Step 5 — Add a Narrative Arc

The sequence isn't random. Every video needs a story structure. The skill uses three patterns depending on video type:

TikTok Reel default: Hook → Build → Payoff → CTA
Ad default: Problem → Solution → Proof → CTA
Brand story: Atmosphere → Climax → Logo reveal

The shot order comes from the narrative pattern, not from whatever pops into your head.

Step 6 — Post-Production Checklist

Because the shots are generated independently, post-production stitching is where it all comes together. The skill always outputs:

[ ] Stitch in [CapCut/Descript/DaVinci] — platform-appropriate tool
[ ] Apply LUT for color consistency — specific LUT suggestion
[ ] Add transitions — types and durations per cut
[ ] Layer BGM — genre, BPM, mood
[ ] Text overlays — hook copy and CTA
[ ] Export — platform-specific specs (9:16 1080×1920 30fps for TikTok, etc.)

Walkthrough: 30-Second TikTok for a Coffee Shop Opening

Let me show you what this looks like end-to-end. The brief:

"30-second TikTok Reel for a specialty coffee shop opening next Saturday. Warm, analog, hand-crafted vibe. CTA: 'Opening Saturday.'"

Visual Theme:

Palette: espresso brown, cream, muted amber, sage green
Lighting: warm golden backlight, motivated window light, 3200K
Lens: shallow DOF, 35mm full-frame
Film: subtle 16mm grain
Motion: locked-off or very slow push-ins

Shot 1 (0-5s) — Hook: The Pour (ECU, overhead)

Extreme close-up overhead shot of hot water pouring from a brass gooseneck kettle into a white ceramic V60 dripper filled with dark coffee grounds, the grounds blooming and rising in slow motion, warm golden backlight with visible steam curling upward, shallow depth of field, 35mm full-frame look, subtle 16mm film grain, deep espresso brown and cream color palette, muted saturation, cinematic 1080p, synchronized audio, 5 seconds, 9:16 vertical

Notice how much of the prompt is visual theme values repeated. That's intentional.

Shot 2 (5-10s) — Setting: The Space (MWS, slow dolly in)

Medium wide shot slow dolly forward into a cozy specialty coffee shop interior, warm morning sunlight streaming through large windows on the left, reclaimed dark wood counter in sharp focus with shelves of handmade ceramic mugs blurred in background, dust motes visible in sun rays, muted sage green wall accents, shallow depth of field, 35mm full-frame look, subtle film grain, warm 3200K color temperature, cinematic 1080p, synchronized audio, 5 seconds, 9:16 vertical

Same palette. Same lens. Same film grain. Different subject, same world.

Shots 3-6 follow the same pattern. The full 6-shot example is in the skill's examples folder if you want to see the whole thing.

Why it works: Shot 1 is sensory (hot water, steam) — the hook. Shot 2 establishes the space. Shot 3 adds a human face (the barista) — the emotional center. Shot 4 is a tactile detail (coffee beans) — signals craft. Shot 5 is aspirational (a customer enjoying the moment) — gives viewers a reason to care. Shot 6 is the CTA reveal. Every shot has a purpose in the emotional arc, and every shot shares the same visual world.

Why Repeating the Visual Language in Every Prompt Matters

This is the part that feels wasteful but is actually the point.

When you generate shot 1 and shot 2 as independent prompts, each generation resets the model's "state." There's no memory of "the last shot was warm 3200K with shallow DOF." If you don't explicitly repeat it, the model will pick its own lighting and lens for shot 2, and you'll get visual whiplash.

The repetition isn't for the model's benefit. It's for your benefit — because it forces you to commit to a visual language before you start generating.

Once you've written "warm golden backlight, 3200K, shallow DOF, 35mm full-frame look, 16mm film grain" six times, you can't half-ass any shot. Every generation is anchored to the same ground truth. That's where consistency comes from.

Where the Skill Fits

I packaged this as a Claude Code skill so you can invoke it like:

Use the ai-video-storyboard skill to plan a 30s TikTok
for my specialty coffee shop opening. Warm analog vibe.

And get the full 6-shot storyboard back in one response. The skill file itself is a single markdown file with frontmatter — dead simple. It also works as:

A .cursorrules file for Cursor
A .windsurfrules file for Windsurf
Custom instructions for ChatGPT / Claude.ai / any LLM

The whole thing is MIT licensed. Free, no account, no signup. If you have more example briefs you want to see as storyboards, open an issue on the repo.

Post-Script: The Broader Pattern

The "shared grammar across many independent generations" problem isn't unique to video. It shows up everywhere in AI content creation:

Image generation — every image in a brand style guide needs the same visual language
Voice cloning — a multi-segment narration needs consistent pacing and emotional tone
Code generation — a feature split across many files needs consistent naming, style, patterns

The solution pattern is the same: a constraint layer above the individual generation that every call has to respect. For video, that's the Visual Theme block. For brand images, it's a style guide. For code, it's project conventions or a linting config.

The stuff AI tools are bad at is rarely the individual generation. It's the coordination across generations. If you find yourself making the same creative decision 10 times and getting slightly different answers each time, you need a constraint layer.

Try It

Skill repo: https://github.com/aicontentskills/ai-video-storyboard-skill
Full worked example: 30s Coffee Shop TikTok

If you want to generate a single video clip, you can try happy horse model, the #1 on Artificial Analysis — delivering expressive motion, precise lip sync, and 1080p cinematic quality in seconds.

What problems are you hitting when you try to make multi-shot AI videos? I'd love to hear in the comments — especially if you've found a different way to enforce visual consistency.