Rate a few examples.
Get your ideal, generated.

Train a tiny classifier on the latent vectors behind generated content — a few dozen swipes is enough — then run it backwards to synthesize what you'd score highest. No prompting. Built at SkinDeep.ai in 2018–19 against StyleGAN, patented, then open-sourced.

Try the live demo Who's building this now The 2019 record

2019

App + patent

~1 ms

Per-swipe retrain

512-D

StyleGAN latent

2025

Open-sourced, MIT

generated samples 👍 👎 👍 👍 each swipe labels a latent vector tiny classifier, latent space retrains in ~1 ms · one per user run in reverse your ideal decoded optimum — or 99% for variety active sampling: the model picks what you rate next generate decode the optimum match & score run forward on real data transform minimal change, target score

"Tinder doesn't ask you to describe your perfect match."

The whole idea, in three steps

People can't describe what they want. They can rate examples instantly.

1
👍👎

Rate

Swipe on generated samples. Each one is fully described by the latent vector that produced it, so every rating labels a point in latent space — no prompts, no tags, no forms.

→
2
🧮

Learn

A single-layer classifier trains on those labeled vectors. It's a few hundred numbers, so it retrains in about a millisecond — after every swipe, per user, on device.

→
3
🔄

Invert

Run the classifier backwards: solve for the latent point it would score 100%, and decode it. That's your ideal — relax to 99% for endless distinct near-ideals.

Operation 1

Generate

Preferential generation: decode the optimum of a taste model — one ideal, a deck of near-ideals, or a blend of several people's models.

See it live →
Operation 2

Match & score

Run the model forward over encoded real-world data. Two people's models can score each other privately — matching without exposing photos.

See it live →
Operation 3

Transform

Find the smallest latent change that reaches a target score, then decode the difference — the makeup-recommendation math.

See it live →

Those three operations are the 2019 provisional patent's title, verbatim: "Latent space classifier for the purposes of preferential generative data, targeted modification of data, similarity matching and scoring."  Read the filing

The demo trains a real model in your browser

Not a video. Not a mockup. A logistic classifier, retrained on every rating you make.

Open the demo

Independently reinvented, piece by piece

Since 2019, the components of this loop have appeared across research and industry — none citing the original. Convergent evolution is the strongest evidence an idea is real.

2021

University of Helsinki

EEG responses to GAN faces trained a classifier; latent-space optimization then generated personally attractive faces — ~80% accurate in double-blind evaluation. The exact mechanism, with the brain as the rating device.

2024

Midjourney personalization

Rank ~200 image pairs, get a personal preference model applied at generation time with dialable strength — the mainstream rate-to-personalize loop.

2025–

"Personalized reward modeling"

Per-user preference models for generative AI are now a named research subfield, with benchmarks — the classifier half of the 2019 filing, formalized.

What still doesn't exist anywhere mainstream: the full loop — millisecond per-user retraining, true reverse classification to the optimum, and private latent-space matching.

Read the full landscape, with sources

It ran for real, in 2019

"Perfection is just a few swipes away"

The original SkinDeep.ai app: a mobile client served StyleGAN-generated faces, each swipe labeled a 512-dimensional latent vector, and a progress ring counted toward every 20th rating — when a GPU worker trained your personal classifier, ran it in reverse, and decoded the face you'd find most attractive. A person who doesn't exist. Then you kept swiping, and it sharpened.

The app, the API, the GPU engine, the patent filing, the demo videos, and an audio overview are all preserved and public.

Browse the record

Screenshot of the 2019 SkinDeep.ai app: a generated face with rating buttons and a training progress ring

For developers

The loop fits on a slide. The engineering is in the sampling, caching, and UX.

# the whole loop, schematically
z    = uniform(-1, 1, size=(batch, 512))   # latent samples
imgs = G(z)                                # any generator with a latent space
y    = user_rates(imgs)                    # 👍 / 👎 swipes

clf  = LogisticRegression().fit(z, y)      # per-user taste model (~1 ms)

z_star = t * sign(clf.coef_[0])            # reverse classification (linear case)
ideal  = G(z_star)                         # decode the optimum

p    = clf.predict_proba(E(photo))         # score real data via its encoding
dz   = ((L_t - L_0) / (w @ w)) * w         # minimal change to hit a target score

Use it, break it, or build the missing pieces

Everything is MIT-licensed. The parts nobody has shipped yet are documented and waiting.

Try the demo Get the code