I replaced every random draw in my user simulator, and it finally became useful
I'm a solo developer in Korea. I built a tool that sends 100 simulated visitors ("virtual residents") to a landing page and shows where they leave. This post is about the engine behind it, and the one decision that made
I'm a solo developer in Korea. I built a tool that sends 100 simulated visitors ("virtual residents") to a landing page and shows where they leave. This post is about the engine behind it, and the one decision that made it work: removing randomness.
You can try it here (free, no signup): https://atelierlaunch.kr/en/residents/
The pipeline
- You paste a URL.
- The server opens the page once in a headless browser, takes a screenshot, and records where every section, link, button and form sits. That becomes a "map" of the page.
- The engine runs in your browser. 100 residents walk the map: they scroll, read parts of sections, open menus, hesitate at buttons, fill forms, or leave.
- You get where each one left, a one-line reason, a star rating, and short interviews.
No LLM runs during the visit. The engine is plain JavaScript functions.
The residents
There is a fixed pool of 1,000 residents. Each one has 97 values on a 0-10 scale, in groups like:
- Personality: curiosity, conscientiousness, suspicion, patience, risk aversion...
- This visit's situation: time available, tiredness, mood, how urgent it is, phone or desktop
- Interests: work, money, health, startups, dev and tech...
- Language: vocabulary, industry jargon, dev jargon, English
- Reading habits: reads closely, skims headings, scroll depth, checks reviews first
- Trust: baseline trust, privacy sensitivity, wariness of unknown brands
The values aren't independent. The five personality traits are drawn with a correlation matrix, and related values are linked through shared latent scores, so a resident who reads closely also tends to tolerate long text. After generation, residents whose values contradict each other are rejected. The age mix comes from Korea's 2025 Internet Usage Survey. More on what that means below.
For a given page, the engine picks the 100 residents whose interests fit it. Fit uses a geometric mean, so one low interest pulls the whole score down:
export const audienceFit = (r, nums) =>
Math.pow(nums.reduce((p, n) => p * (r.값[n].값 / 10), 1), 1 / nums.length);
(Yes, the field names are Korean. It's a Korean codebase.)
From 97 values to behavior
The engine doesn't use the raw values directly. It mixes them into a few core behavior values through a weights table. For example, the attention budget (how many seconds this visit can last) is mostly "time available", plus a little tiredness, patience and urgency. The mix x (0 to 1) becomes seconds:
// 0 → 20s, 0.5 → about 2m14s, 1 → about 15 min
const budgetSeconds = 20 * Math.exp(3.8 * x);
One rule I keep: personality can never be more than a fifth of any mix. Situation and habits should drive behavior more than "who you are", and a test enforces it.
Every row in the weights table is marked either "sourced" (the scale comes from published data) or "assumption". Most of them are assumptions, and I'd rather say so.
The problem: luck was deciding the results
The first version was a probability model. There were 17 random draws: whether a resident stays on the first screen, misclicks, gives up on a form field, hesitates at a button, leaves at each section...
Then I sent the same 100 residents to the same page, changing only the random seed. The number who reached the end swung between 3 and 10. The average star rating moved between 3.19 and 3.60.
That killed the one thing I wanted the tool for: "I changed my headline. Did it get better?" With that much noise, you can't tell your change from a lucky roll.
The fix: decisions from "intent", not dice
I removed every random draw and replaced them with two patterns.
One-time decisions (stay on the first screen? click the button?): compute an intent between 0 and 1 from the resident's values and what they've seen so far. If it's above a cutoff, they do it.
Repeatable things (misclicks, giving up field by field, the risk of leaving at each section): intent accumulates, and the action happens when it passes one half.
The tricky part was the cutoffs. A single global cutoff created cliffs. With a page that took 4 seconds to load, 69 of 100 residents left on the first screen, far more than the old probability model predicted. So now the cutoffs are re-fitted on every run, for that page and those 100 residents (at most 10 iterations). The number of residents who do something matches what the probability model would expect. Which residents do it is decided by who has the strongest intent. Nobody gets lucky.
Same page, same result, every time. The seed now only picks which sentence template a resident uses to say the same thing.
Does it respond to the right things?
On my own landing page, with the deterministic engine:
| Change | Result |
|---|---|
| One character changed in a menu label | All 100 residents behaved the same |
| First screen text 233 → 600 chars | Stars 3.58 → 3.43 |
| Example added to the first screen | Stars 3.62, first-screen exits 20 → 15 |
| Description text 628 → 300 chars | Stars 3.64 |
| Email field added to the first form | Residents who finished: 9 → 6 |
And moving a single value from 0 to 10 across the 100 residents shifts the finishers in the direction you'd expect. Suspicion: 12 → 7. Time available: 3 → 11. Interest in startups: 1 → 12.
A side effect: everyone took the same path
Without randomness, the number of distinct paths dropped from 43 to 27. On the first two sections, "scroll down" beat every other option by a wide margin for everyone. The old random noise had been the only thing splitting the paths.
I didn't want to add the noise back, so I let personality split them instead. Heavy menu users click menus more. Skimmers click menus more than close readers. Suspicious residents are drawn to links like terms, privacy, FAQ and "about". Links that leave the mapped page now count as "went to another page" rather than "left because they didn't like it". Distinct paths went back up to 37, while the stars and finishers stayed where they were.
Interviews without randomness
You can interview the residents who left a review: how they arrived, what caught their eye, why they left, whether they'd come back, who they'd tell. At first, answers came from probability draws, so 88 of 100 residents said "nobody" to "who would you tell?", even five-star ones. Now each answer is built only from what that resident actually did and felt on this visit, plus their situation and personality. Across 100 residents, each question gets 42 to 87 different answers, and the same result always gives the same answer.
Things the engine refuses to do
- It never reads gender, region or income. The pool has them only to match population ratios. Reading them throws an error, and a test checks that.
- It doesn't claim to be evidence. Five engine settings are tuned to public web averages, and they match only some of the ten benchmarks I check against. The pool is calibrated to Korean internet users. On English pages, residents read English, and English isn't counted as "hard words" there, but they are not a model of a US audience.
So treat it as a hint about where to look, not proof.
Try it
https://atelierlaunch.kr/en/residents/
Free, no signup, 3 runs a day. If you run it on your page, I'd most like to hear where it gets things obviously wrong.
Originally published by Dev.to WebDev. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.