Case study · SyntheticMe · 2025 to present
An AI twin that
can prove it.
Two hours of voice interview become a twin that answers only from your own approved words, cites the second of tape behind every claim, and says "I don't know" instead of inventing. I researched it, designed it, wrote every line, and deployed it. Alone.
Because I read it properly and it didn't deserve to ship. Six routes accepted a user id from the client alongside a service key, so any user could have read anyone's memories. There were four different Memory types and stubs returning confidence numbers that were never computed.
For a product whose whole promise is that it doesn't make things up, fabricated confidence is fatal. So I deleted 21,000 lines and rebuilt against rules I wrote down first.
An illustrative exchange, built from things I actually said and wrote. The real corpus is private, which is rather the point. Hover or tap a citation.
01 The problem
Every clone will eventually lie about you.
Fifteen years of "preserve yourself" startups have died or pivoted. Intellitar, Eterni.me, StoryFile's bankruptcy, Eternos' pivot. The survivors sell to creators or enterprises. Nobody fixed the thing that makes the whole category unusable: a clone that confidently invents a memory in your voice is worse than no clone at all. The first time your daughter catches it making something up, every true thing it ever says is suspect.
So the design question was never "how do we make it sound like him." It was "how do we make it structurally incapable of lying about him." That reframing decided the architecture, the interface, and what the product refuses to do.
The guardrail is a sentence in a prompt. Sentences get overruled.
The guardrail is a column in the database. Columns can't be talked out of it.
02 Research first
I built the instrument before I built the interface.
The mechanic is real. In 2024 Stanford showed that agents built from a single two hour interview matched their subjects' real answers at 85 percent of the rate people agree with themselves two weeks apart, across 1,052 participants. The result rests on a specific interview instrument, not on a model. So the interview came first.
The protocol is a 117 minute, twelve module script assembled from four validated sources: McAdams' Life Story Interview for narrative identity, the Stanford and Princeton American Voices instrument behind the 2024 result, Aron's escalation gradient for why intimacy has to build in tiers before people stop retreating, and the Adult Attachment Interview's signature move, where you ask for an adjective and then demand the specific episode behind it. The gap between the claim and the episode is the data.
- 00Framing2 min
- 01The story of your life10 min
- 02Your life right now12 min
- 03Key scenes: the peaks and the pit20 min
- 04Your own lens10 min
- 05What you value12 min
- 06How you decide8 min
- 07Where you come from12 min
- 08What you believe10 min
- 09The deep set10 min
- 10Forward and meaning8 min
- 11Close3 min
Three design rules fell straight out of the literature. Episodes are the default answer format, never trait self description. Breadth early, depth late. And the first twenty five minutes have to stand alone, because Stanford's ablation showed a fifth of the transcript carries most of the signal, and real people quit. The protocol lives in the repo as a document and again as executable code, with a rule at the top: if the code and the document disagree, fix the code.
03 The decision that is the product
Grounding is a column, not a prompt.
Every competitor treats grounding as an instruction to the model. Instructions are suggestions. So in SyntheticMe, evidence gating is a column in the database.
Each extracted memory carries a status. Only approved rows are retrievable. The retrieval function literally cannot see anything the subject has not personally read and accepted, which means the twin cannot cite a memory that was never approved, no matter what the model would like to say. The guarantee lives in the schema, where a prompt change can't undo it.
match_memories() retrievesThe same instinct shaped three more decisions.
Dual provenance, or no memory
Every memory stores the transcript span and the audio timestamp range it came from. A memory that can't cite its source span doesn't get created. One day the Why panel plays the clip of you saying it.
Explicit beats inferred
What you actually stated lives in its own table and one resolver enforces that it overrides anything the model concluded. Contradictions become questions back to you, never a quiet coin flip.
"I don't know" has a job
Every unknown writes a row to a gap queue, and tomorrow's questions are generated from measured gaps rather than a template. Ignorance becomes the roadmap.
04 The experience
You meet your twin before you build it.
Every capture product opens with a form. This one opens with a camera. The moment you begin, the screen becomes a mirror: your face, softly lit, nothing else. While you talk it reads your expressions and your cadence. Then a second face fades in beside yours, and speaks.
It asks your name. You say it. And from that sentence on, its voice slides toward yours, one line at a time, until "Hello, Amir. It's nice to meet you" already sounds a little like Amir. It asks if you're ready to build your synthetic self. You say yes. Then it asks the first real question, and the two hour interview has begun without ever feeling like one.
The design rule underneath: the interview only works if the person forgets it's an instrument. Everything in the opening minute exists to earn that.
The face is mine. In the shipped shell the avatar is a live second render of the camera feed that sharpens only when something real happens: camera on, name heard, consent given. No percentage is shown in the product, because nothing is measured yet; the frames above show the intent.
- The evidence engine: extraction, approval gate, hybrid retrieval, answers that cite or decline
- The 117 minute interview protocol, encoded and running voice first
- Maturity computed live from coverage, method printed beside it
- The Personal Turing Test harness with scoped judge links
- The public sign up, with the five synthetic people moving, and a waitlist that saves
- The first sixty seconds as a working shell: camera mirror, the avatar that sharpens on real milestones, spoken greeting, name by voice, hand-off into the interview
- CI on every push, nightly live model verification, nightly archive
- Expression reading in the opening minute
- The voice that slides toward yours (today it speaks in the twin's pinned voice)
- The avatar as a true likeness rather than a render of the live feed
- Playable audio provenance in the Why panel
What's deployed today is deliberately unstyled: a harness I use every day to test whether the conversation feels natural, whether the twin declines when it should, whether the citations hold. It exists to get the flow right before a single pixel of the surface is committed. That's why it isn't pictured here. The engine is the product's spine; the experience above is its face.
05 Building it
There was a first version. I audited it, then deleted it.
In late 2025 I built 21,000 lines of prototype. In August 2026 I read it the way a reviewer would and wrote the code review myself. It had never been deployed because it had never compiled cleanly. So I rebuilt it in roughly 6,600 lines against eight rules I wrote down before touching the editor.
The engineering constitution
- Red CI means the code doesn't exist. The pipeline runs against recorded fixtures so it never goes red because a model provider is slow. Live model verification is nightly.
- No stub returns a fake value, ever. Throw, or return honest null. Fabricated confidences were the old repo's deepest disease.
- One implementation per concept. One Memory type, one client, one chat surface, one question engine.
- Commit means compiles and runs. Progress is a working state, not generated text.
- The service key never appears in a request handler. Identity comes only from the session. Named as a rule because the sin was committed once.
- One sacred end to end test: interview, approve, ask, see the citation. It would have caught every failure in the old codebase.
- Prompts are versioned files in the repo, never inline strings, so the prompt hash on every answer means something.
- User words are irreplaceable. A nightly job snapshots the corpus, because once real interviews exist the database is the only copy of a person that will ever be made.
06 Proof
A fidelity product has to publish its fidelity.
The claim is fidelity, so the product measures fidelity or it's a demo. The method is Stanford's, and the number goes on the product page whatever it turns out to be. A fidelity product that won't publish its score is selling the same promise as everyone in the graveyard.
The human ceiling
Fifty questions, frozen. I answer all fifty, then answer them again two weeks later without looking. That sets the ceiling: how consistent I even am with myself. The clock can't be compressed.
The twin, scored against me
The twin answers the same fifty and is scored against my own self agreement, not against perfection. Every answer's recipe is logged, so the set replays on every prompt or model change as a regression test.
The blind test
Family and friends score paired answers, mine against the twin's, without knowing which is which, through scoped expiring links. The result is a number, not an adjective.
Fifty answers, then the same fifty two weeks later without looking. The gap between them is the ceiling every score is measured against.
15 of 22 scaled answers land within one point of my own baseline. All 50 answered. Interim, not the headline.
The number that goes on the product page. It stays blank until the people who know me have scored it.
07 What's not done
The honest ledger.
- The headline fidelity number is still blank. The twin has sat the exam (50 of 50 answered; on the scaled items, 15 of 22 land within one point of my own baseline), but the blind judging by people who know me hasn't happened yet, and I would rather show a blank than a projection.
- There are no unit tests. The end to end suite covers auth boundaries, not yet product behavior.
- Every commit went to main without review. That is the honest cost of building alone and the first thing I'd change with one more person on the project.
- Style fidelity, writing exactly the way a person writes, is scientifically unsolved. The product promises memory and judgment, and deliberately doesn't promise mimicry.
Coda · The public face
The emotional argument, kept apart from the instrument.
The sign up is the one place the product is allowed to feel before it proves. Five synthetic people wake up across the top of the page, from a grey blur into someone laughing, talking, looking around, and keep living while you read. The copy is the founder's, one sentence per idea. There is no counter and no countdown; the form asks for an email and says exactly what happens next, because the product onboards one person at a time while the fidelity test runs.
It began as a Figma concept with a purple gradient. What shipped keeps the faces and the mood, drops the gradient, and inherits the quiet black and evidence green of the instrument behind it.
Open the hood
Claims about coding are cheap. A running product isn't.
The sign up is live, the engine behind it is deployed, and the repository, the CI, and the written constitution are all there to walk through. If you're hiring a designer who ships, this is what shipping looks like.