How the work gets made.

Brands and creators who use an AI character need the same face in every post. Image models drift: change the light, the angle or the outfit and the face slowly turns into someone else. Most portfolios answer this with a grid of nice pictures and the word consistent.

A grid only shows that the pictures look similar to the person who made them. I wanted a measure a client could check: one reference image, twenty very different scenes, and a face-similarity score for every frame.

The character starts as one front-facing reference portrait. Every scene is generated locally in ComfyUI from that single image and a written prompt: an image model with an identity-edit LoRA, no character LoRA, 8 steps at 832 × 1152.

The prompts follow a fixed structure of nine labeled blocks, so identity, clothing, pose and light are never mixed in one sentence. The subject block holds the face; the other eight change the world around it. This is the real prompt behind scene 01:

Subject

The same woman as in the reference photo with her exact facial identity, dark brown shoulder-length bob with heavy curtain bangs, brown eyes, a small dark mole on her left cheek

Outfit

Black belted trench coat buttoned to the collar

Pose

Body turned three-quarters away, a clear umbrella resting on her shoulder

Action

Glancing back over her shoulder mid-step, raindrops beading on the umbrella

Scenery

Narrow neon-lit Tokyo side street at night in light rain, wet reflective pavement

Camera

Vertical portrait at eye level, waist to just above the canopy, shallow depth of field

Lighting

Warm shop-window light mixed with pink and blue neon, her face the brightest area

Expression

Faint knowing half-smile with closed lips

Style

Photorealistic, natural skin texture with visible pores, flyaway hairs, correct anatomy

Shortened for the page; the full prompt is longer in every block.

The scorer is OpenCV's YuNet face detector with the SFace recognition model, comparing each scene to the reference shown above by cosine similarity. SFace's threshold for "same person" is 0.363. All twenty scenes clear it, with a mean of 0.69, a lowest score of 0.45 (the concert) and a highest of 0.92 (the studio).

• A control, not just a score. Three different characters scored against the same reference land between 0.02 and 0.10. Without them, 0.69 would be a number with nothing to compare it to.
• Prompt shape is a lever. The first sheet wrote each scene as sentences. The second rewrote the same scenes in nine labeled blocks, with the same model and seeds. Scored against the generation reference, the mean rose from 0.63 to 0.68.
• A score is not the whole verdict. Twelve scenes come from the second sheet and eight from the first: where the older version had the stronger expression or frame, or the new one let a black turtleneck leak in from the reference, the older one was kept.
• Light decides identity. One test with the face in shadow scored 0.32, the only frame below the line. Rewriting how light falls on the face lifted it to 0.61.
• Motion is the next frontier. Scored frame by frame, one 5-second image-to-video clip of the café scene averaged 0.36, with 11 of 21 sampled frames under the line; the flower-market clip held at 0.62.
• Next: a trained character LoRA scored beside this single-reference run, then clips that hold the line in every frame.

AI assistants are capable but forgetful. Every new session starts from zero, the same mistake can be made twice, and the useful context from last week sits in a chat nobody will scroll back to.

I wanted the opposite: a system where state is written down precisely, each kind of job has one owner, and a correction made once is followed from then on.

AIOS is a Git repository that Claude Code runs inside. It holds validated records for projects, tasks, decisions and lessons, a searchable library of research and notes, and a set of specialist skills and subagents. A session starts by loading the current state; a hook checkpoints changed files back to the repository when it ends.

One rule shapes everything: each job has exactly one owner, the newest and most capable version, so the system never has two half-working ways to do the same thing.

I started it in June 2026 on Claude Code; this is its third generation, and the earlier two are kept as reference, not deleted. It carries 83 lessons, 50 of them verified by outcomes, most of them born from a correction of mine.

• Scoped claims. Reports state only what a tool result verified in that session, and label the rest unverified.
• Spend and send gates. Purchases, paid API runs and anything sent in my name always wait for my approval.
• Budgets enforced by tests. The instructions file has a size budget that a test checks, so the rules stay short enough to be followed.
• Next: fewer, sharper rules. Lessons that prove themselves get promoted; the rest stay candidates.