I Turned One AI Influencer Into a UGC Factory. Here's the Build and Where the Money I$.

The core idea: identity is data, not a vibe.Most people build an AI influencer like a napkin doodle. I build mine like a shipped binary: one JSON identity card, one Claude Code skill, a full week of content from seven one-line briefs. Here is the entire system, and where the money actually comes from.

Here is the line that rewired how I think about this whole game: the character is not an image. It's a build artifact.

If you've been doing this by hand, hoarding reference faces, pasting a wall of text into a chat window, praying the next render still looks like the same woman, you already know the failure mode. So let me show you exactly how it kills your account, then the system that kills it.

Your AI influencer dies at video #2

Here is how it always goes.

You generate a gorgeous first image. The face is perfect. You're hyped. You post it, people react, and you're sure you've cracked the cheat code to a faceless brand.

Then you sit down to make the second piece. And she's a different person.

The jaw is wider. The skin shifted half a shade warmer. The hair went from golden blonde to dishwater. The eyes that were green are now a confused hazel. You re-upload the original, you write a paragraph begging the model to "preserve facial structure, do not beautify," you regenerate four times, and you land on something that's close enough if you don't look too hard.

Video #3, same fight. Video #4, same fight. By video #7 you're burning an hour a post babysitting a face that refuses to stay one person, and you quietly stop posting.

That's the real death of most AI influencers. Not ugly images. Inconsistency. The character can't survive contact with a content calendar. You're not running a brand. You're running a slot machine.

Here is what nobody tells you: the problem isn't your prompts. The problem is that you're prompting at all.

I stopped pulling the lever. Now I compile.

This is the engineering version of the AI-influencer playbook. The character lives as a Claude Code skill plus a JSON identity card. Generation runs through a skill I wrote once and reuse forever. Video renders through Kling 3.0 on fal.ai. The whole thing is deterministic, version-controlled, reproducible. One line in, a production-ready shot out.

Let me walk you through the build.

The core idea: identity is data, not a vibe

When you re-upload a reference image and beg the model to match it, you're treating identity as a vibe, a soft suggestion the model reinterprets fresh every single time. Interpretation drifts. That's why she changes. A picture is a vibe, and a vibe drifts.

I treat identity as a schema.

Every actor I run is a JSON object, a literal file I own, version, and diff like any other config. It becomes two things working in tandem:

Code, not clicks. A schema, not a guess.

Once identity lives in structured data, consistency stops being something you hope for after the fact and becomes something the system guarantees up front. The same card produces the same person. Full stop. You can't drift from a primary key.

The identity card: your single source of truth
This is the heart of the system. Here is the source of truth for one of my actors. Meet Lila:

{
  "actor_id": "lila_v1",
  "name": "Lila",
  "origin": "Swedish",
  "age_range": "21-23",
  "face": "soft oval, high cheekbones, small straight nose, gentle rounded chin",
  "eyes": "pale blue-grey, slightly hooded, left eye 2% smaller",
  "skin_tone_hex": "#F8C4AE",
  "skin_notes": "fair, rosy undertone, faint freckling across nose bridge",
  "hair": "golden blonde, natural wave, mid-chest length, center part",
  "jawline": "delicate, soft, slightly asymmetric, left side a touch softer",
  "distinguishing_marks": "small mole below right jaw, faint scar left eyebrow, freckle on left collarbone",
  "outfit_variations": ["oversized cream knit", "linen slip dress", "athleisure set"],
  "prompt_seed": 48217
}

Look at skin_tone_hex. It isn't "fair skin." It's # F8C4AE. An exact value, not a poetic phrase the model can read nine different ways. The same hex compiles to the same skin every time. No drift, because there's nothing left to interpret. That's the gap between describing a person and defining one.

That's the whole trick, scaled across every field. eyes pins a 2% size difference. jawline pins a deliberate asymmetry. distinguishing_marks fixes a mole, a scar, and a freckle to specific real estate on her body. prompt_seed anchors generation. The card doesn't describe a type of person. It defines one specific person and refuses to let her become anyone else.

Because identity is data, consistency stops being luck and becomes a property of the system. Claude rebuilds the same person from the card every single time. No re-uploading. No "use exactly the same synthetic person" paragraph you copy-paste and cross your fingers over. The person is the file. Lila walking out of the sea at golden hour and Lila filming a skincare testimonial in a bathroom are unmistakably the same human, because both began from the same JSON object, not from two separate attempts to re-describe a saved image.

Image-as-source-of-truth degrades a little with every regeneration. Data-as-source-of-truth doesn't degrade at all.

Here is the part that makes it scale like software: the card is portable. I can hand Lila to a teammate and they generate the identical character. I can fork her into a sister actor by changing four fields: darken the hair, drop the freckles, shift the origin, reroll the seed. I can spin up five actors from the same engine before lunch. Try that with a saved JPEG.

The skill: write the spec once, generate forever

The engine itself is a Claude Code skill I call ugc-creator.

If you haven't built a Claude skill yet: it's a packaged capability you teach Claude Code once, instructions, logic, reusable structure, then invoke on demand. Think of it as a function you install into the model. You define the behavior once. From then on you call it instead of re-explaining it. Mine encodes everything about how a believable UGC shot gets constructed:

One command to Claude Code stands up the entire UGC engine. I wrote the spec one time. From then on, the influencer isn't a workflow I re-run by hand across five tabs. She's infrastructure I own. Reproducible. Version-controllable. Shareable. After that I'm not "making images" anymore. I'm calling a function.

That's the whole philosophical move. The manual approach is a workflow, a chain of clicks you re-run by hand every time, that breaks the moment you misremember a step. My approach is a program. I describe the behavior once. The behavior is now repeatable, inspectable, and shareable.

This is the part people miss. The deliverable isn't the video. The deliverable is the machine that makes the videos. That machine is the moat. Anyone can write a clever prompt, and a clever prompt is a disposable artifact. A skill is a durable one. Build it once, reuse it forever, fork it for the next actor. The leverage compounds the way good code compounds and clever prompts never do.

The realism engine: engineer the flaws on purpose

Here is the counterintuitive core of the whole system.

Realism doesn't come from beauty. It comes from imperfection.

AI images fail the eye not because they're ugly but because they're too clean. Poreless skin. Perfect symmetry. Flawless lighting. Hair that looks airbrushed. Your brain clocks "rendered" in a quarter of a second, even when it can't say why. The "AI demo" smell is the smell of zero flaws.

So I don't let the engine produce zero flaws. I inject them. The ugc-creator skill carries 10 mandatory realism anchors, and every shot gets all ten, no exceptions:

That's the engineering insight most operators miss: you design the imperfection deliberately. A real photo is full of tiny accidents. If your generator produces a face with no accidents in it, you haven't made a person. You've made a render. You don't make her prettier to look real. You make her flawed on purpose. Pores over polish. The mole stays. The asymmetric jaw stays. The flyaway stays.

This is the layer that separates "obviously AI" from "wait, is that real?" And because it lives in the skill, I never have to remember it. It fires on every shot, automatically, forever.

iPhone camera simulation: shot on a phone, not rendered

The second realism lever is the camera itself.

"Cinematic" is a tell. Real UGC looks like it was filmed on a phone in someone's bathroom by a tired person with one hand, because it was. Not "rendered on a GPU farm." So the skill carries four iPhone camera simulation profiles, and each one models how that specific capture actually behaves:

Each profile carries its own grain signature, focal feel, and handheld micro-shake. A real phone shot trembles a little. A real front camera flattens features a touch. A real mirror selfie has a smudge and a flash bloom. Bake those quirks into the profile and the output stops looking generated and starts looking captured.

You're not choosing a pretty camera angle. You're choosing a believable capture device.

The 6-layer prompt system

This is the engine room of ugc-creator. For every shot, the skill doesn't hand the generator a sentence. It assembles a stack out of six ordered layers. The order isn't decorative. It's load-bearing.

Layer 1, Character lock. Pulled straight from the JSON card. Face, eyes, # F8C4AE skin, hair, jawline, the mole, the asymmetry, the seed. This layer is non-negotiable and always first. It's the gravity the rest of the prompt orbits. Everything downstream can move. This cannot.

Layer 2, Scenario. What's happening. "Just walked out of the sea." "Mid-skincare routine." "Unboxing a parcel on the kitchen counter."

Layer 3, Environment. Where, and the light it implies. "Golden-hour beach, low warm sun, wet sand." The environment dictates the physics of the lighting.

Layer 4, Camera. Which iPhone profile, framing, distance. "Front selfie cam, arm's length, slight upward tilt."

Layer 5, Realism injection. The 10 anchors, fired in.

Layer 6, Negative prompt. Everything I refuse. "No plastic skin, no perfect symmetry, no airbrushing, no extra fingers, no CGI sheen, no beauty-filter smoothing."

Character lock first. Always. The most common way a manual build dies is letting the scenario or the camera override the identity. You ask for a dramatic angle and the model quietly reshapes the face to fit it. Here, everything downstream bends around who she is. The lighting never gets to renegotiate her jaw. The lock isn't a hopeful sentence stapled to the top of a fresh prompt. It's the foundation the whole prompt is poured onto, and the skill lays it the same way every time, not from my memory at 11pm.

The shot library: 7 UGC types, reusable

UGC isn't infinite. Real creator accounts run a predictable set of formats, a small, reusable vocabulary that actually drives engagement. So the skill ships a library of 7 UGC shot types, each with its own scenario defaults, preferred camera profile, and framing logic:

I don't reinvent "what does an unboxing look like" each time. I call the shot type, the skill loads its defaults and grammar, and the 6-layer build fills in around the identity card. Compose, don't author from scratch.

The brief: one line in, a full build out

Here is where the whole thing pays off, where it stops feeling like image generation and starts feeling like a compiler.

I give Claude one line:

Lila, just out of the sea, wet hair, golden hour

That's the entire input. The skill does the rest:

One line of intent becomes a production-ready, fully-specified prompt. That's the compiler model in a single motion: high-level intent in, low-level build out. I write the what. The skill handles the how.

Now multiply it. Once the card and the skill exist, the marginal cost of a new shot is one sentence. A week of content is seven one-liners:

Lila, morning coffee, oversized knit, window light
Lila, gym mirror selfie, athleisure, post-workout flush
Lila, unboxing skincare, kitchen counter, overhead
Lila, GRWM, bathroom mirror, half-done makeup
Lila, beach walk, linen dress, golden hour
Lila, testimonial, holding serum, soft front light
Lila, night out, restaurant lighting, mirror selfie

Seven lines. A full content calendar. The same person in every frame, because every frame compiles from the same card. It scales like software because it is software. That's how you scale a face.

Video: Kling 3.0 on fal.ai, directed like a programmer

Stills get you a feed. Video gets you a creator. And motion is where most AI influencers fall apart. The face warps, the hands melt, the whole illusion collapses inside the first second.

I render video with Kling 3.0 through fal.ai: strong realism, clean handling of small human movement, and API access that drops straight into the pipeline instead of becoming one more tab. I direct it with a tight rule-set, because video models reward restraint and punish ambition:

The discipline here is the discipline everywhere else in the system: constrain the model so it can't wander. Small, controlled motion on top of a rock-solid identity is the combination that makes people forget they're watching a generated person.

The consistency protocol: ship a whole week as one person

A single good video is easy. A batch of twelve that are obviously the same woman is where most setups fall apart, and where this one wins, because consistency was never left to chance.

When I generate a batch, the skill enforces hard locks across every shot:

That last lock matters more than it sounds. Consistent asymmetry is what reads as a real individual. Real faces aren't mirror-symmetric, and they're consistently not symmetric, the same flaws in the same places, shot after shot. Most drift happens because the model "fixes" her: smooths the jaw, moves the mole, evens the skin. The protocol explicitly preserves her flaws as identity features. The asymmetry isn't noise to clean up. It's part of who she is, and it's pinned in the card.

Because all of it sources from one JSON card and assembles through one skill, the locks hold automatically. I'm not eyeballing twelve images side by side hoping they match. The system guarantees the match. A whole week of posts is obviously the same human, by construction, not by luck.

The optional sound layer

Once the visuals are locked, you can finish with voiceover and music: a synthetic voice on the testimonials, a bed of music under the lifestyle clips. It's a real step, and it polishes the output.

But be clear about what it is: garnish. Swap the voice, swap the track, and Lila is still unmistakably Lila, because her identity never lived in the sound. It lived in the data. The moat is the skill plus the card. Don't confuse the finish for the foundation.

Where the money actually comes from

Here is the part the engineering crowd skips and the money crowd leads with. A consistent, on-demand creator who never needs a camera, a studio, or a day rate is not a party trick. It's a production company with one employee who works for the price of an API call. Five ways that turns into income:

Framed honestly: none of this is automatic, and the first dollars lag the first posts. You still have to pitch brands, build an audience, and pick niches people actually buy from. But the unit economics are unlike anything a human creator can touch. A human UGC creator films one video at a time. You compile a week in an afternoon, and the marginal cost of the next one is one more sentence. That gap is the entire opportunity.

Why this beats clicking around

Let me put the contrast plainly, because it's the whole argument.

Identity is a JSON schema, not a re-uploaded image. Consistency becomes deterministic instead of hopeful. The same card compiles the same person, no degradation across regenerations, because there's no re-interpretation. You can't drift from a primary key.

One skill replaces a pile of tools and a manual dance between them. The whole pipeline is reproducible, version-controllable, shareable. No tab-hopping. No "wait, which tool did I export that from?"

The realism engine engineers imperfection on purpose. Ten anchors on every shot kill the plastic look automatically, no remembering, no manual touch-up. Flaws by design are what kill the "obviously AI" look that gets content scrolled past.

One card plus one-line briefs generates a full calendar. The marginal cost of content collapses to a sentence. A week of posts is seven lines. Production scales like software, because it is software now.

The skill is the asset. Build it once, own it forever, fork it into a roster of actors from the same engine. You're not making influencers one at a time. You're running a factory that makes them. Every shot you generate makes the engine more valuable, not more tired.

The manual operators are right about one thing: an AI influencer is a system, not a single magic prompt. We just disagree about what kind of system. Theirs is a checklist, a sequence of human steps held together by discipline and memory. Mine is a program, a spec that executes the same way every time, whether I'm sharp or exhausted, whether it's shot one or shot one thousand.

The manual crowd is still on video #2, re-uploading a reference image and praying the jaw holds. You've got a compiler.

Checklists rot. Programs compile.

Start building

You don't need my exact setup to begin. You need the mental shift.

Stop describing your character and start defining her. Open a file. Write the JSON card: face, eyes, the exact skin hex, hair, jawline, the deliberate asymmetry, the seed. Make identity data.

Then wrap your generation logic into a skill instead of a saved prompt. Encode the 6 layers. Bake in the 10 anchors. Add the camera profiles. Now you don't have a prompt you re-paste. You have an engine you call.

Feed it one line. Watch it compile a full build. Then feed it seven lines and ship a week.

Describe her, and she drifts, a slightly different person every prompt, dead by the second video. Define her in data, compile her with a skill, and she becomes infrastructure: consistent, scalable, owned, built to ship. The people still re-uploading a JPEG into a chat box are making images. You'll be running infrastructure: an actor you own as code, a realism engine that fires on every frame, a content calendar that compiles from a single source of truth.

Don't prompt an AI influencer.

Compile one.

I'm building the ugc-creator skill and the identity-card system in the open. Comment "COMPILE" and I'll send the actual schema, the realism anchors, and the briefs that turn one line into a week of content.