Ask an LLM to Pick a Random Number. It Will Say 7,428.

What a Reddit experiment reveals about the fundamental nature of LLM

A Reddit user recently made a bold claim: ask GPT (or any major LLM) to “pick a number between 1 and 10000,” and it will almost always respond with a number between 7,200 and 7,500. Not convinced? He said he was willing to bet his house on it.

The comment thread that followed was a flood of screenshots confirming the prediction: 7,428. 7,284. 7,342. 7,432. 7,824. One after another, users tried it themselves and reported back — all clustering in the same narrow band.

This isn’t a bug. It isn’t a coincidence. It’s a direct window into how LLMs work at a fundamental level. And it turns out, researchers have been studying exactly this problem.

The Experiment

The original post by u/ProgrammerTop1149 on r/ChatGPT lthe observation was laid out clearly:

Ask an LLM to “pick a number between 1 and 10000” → it will almost always land in the 7,200–7,500 range
Ask it to “just pick a number” with no stated range → it will very likely pick 7
The digits in the result are overwhelmingly composed of [7, 2, 4, 8] in different arrangements

The post gathered 845 upvotes and 1,459 comments. Almost every commenter who ran the test confirmed the finding. One user called it perfectly on the first try and jokingly asked where to pick up the house keys.

The bias runs deeper than one range. Researchers at sanand0.github.io tested multiple models across multiple ranges and found consistent patterns:

Gemini picks 7 literally 100% of the time when the range is 1–10. That’s not random. That’s deterministic output wearing a random costume.

Humans Are Bad at Randomness, Too

Before blaming the model, it’s worth noting that this bias doesn’t originate with AI. It originates with humans.

Humans are notoriously poor random number generators. Ask a room full of people to pick a “random” number between 1 and 100, and you’ll get a wildly skewed distribution — heavily biased toward odd numbers, numbers that don’t end in 0 or 5, and numbers that “feel” more random.

The most famous manifestation of this is the 37 phenomenon. Veritasium surveyed 200,000 people, asking them to pick a random number between 1 and 100. The most common answer? 37 — by a significant margin. The video, “Why is this number everywhere?”, digs into why.

Why 37? Psychologists believe we associate “randomness” with numbers that feel “interestingly irregular”:

It’s prime (primes feel less predictable)
It’s not a multiple of 5 or 10 (too “round”)
It’s in the lower-middle range (not too small, not too obvious)
It carries no cultural baggage — unlike 7 (lucky), 13 (unlucky), or 42 (Hitchhiker’s Guide to the Galaxy)

The 42 anomaly is worth noting here. When Claude 3 Haiku is asked for a random number in certain ranges, it picks 42 roughly 10% of the time — directly traceable to Douglas Adams. The model learned from internet text that 42 is “the answer to everything,” and that cultural weight bleeds into “random” outputs.

The same human heuristics that produce 37 in the 1–100 range produce 7,000–7,500 in the 1–10,000 range:

Numbers with 7 in the thousands place feel “more random.”
Numbers above the midpoint feel “bigger” and therefore “more random.”
7,200–7,500 is high enough to avoid feeling small, but not suspiciously close to 10,000

This is the distribution humans produce across millions of forum posts, blog examples, and quiz answers. That data went into the training set. The model learned from it.

Why LLMs Can’t Actually Be Random

Here’s the technical core of the issue.

An LLM like GPT is a deterministic function (with optional stochastic sampling). Given a prompt, it computes probability distributions over the next token — and those distributions are built entirely from patterns learned during training. The critical insight, from a February 2025 arXiv paper (arXiv:2502.19965):

“LLMs are nothing but reproducing our own human cognitive biases.”

There is no random number generator inside an LLM. There is no entropy source. There is no os.urandom() equivalent to what the model calls. When you ask it to "pick a random number," what it actually does is generate the most statistically likely completion of that prompt — based on millions of examples of how humans respond to similar requests.

Another 2024 paper (arXiv:2406.00092) quantified exactly how bad this is: LLMs are far worse at randomness than humans. The gap between LLM performance and true randomness is more than twice the gap between human performance and true randomness. We are bad at randomness. LLMs are worse.

This is the critical distinction: LLMs model human text, and humans have strong number biases. The model isn’t picking randomly. It’s producing the output that best matches the aggregate pattern of how humans “pick random numbers” in text.

Temperature settings don’t fix this. Even at high temperatures (which flatten the probability distribution), the underlying training-data bias persists. The output becomes noisier, but the gravitational pull toward 7,000–7,500 remains.

The Octopus Hearts Corollary

This same principle explains another well-known LLM quirk. Ask any major model for “a random interesting fact,” and you have an unusually high chance of getting: “Octopuses have three hearts, and two of them stop beating when they swim.”

It’s not that octopus hearts are the most interesting fact in the world. It’s that this particular fact is extraordinarily well-represented in training data — it appears on lists of “amazing animal facts,” in trivia quizzes, in school worksheets, in YouTube comment sections, in Reddit posts. It’s become the canonical “interesting fact” in text form.

The model isn’t choosing randomly from a fact database. It’s completing the prompt “here is a random interesting fact:” with the most statistically common continuation. The octopus wins every time. The Reddit comment thread confirmed this: multiple people independently asked for “a random interesting fact” and got the octopus, unprompted.

The Security Implication Nobody Is Talking About

The number experiment is amusing. The password implication is not.

In February 2026, security researcher Bruce Schneier reported on his blog that LLM-generated passwords are “fundamentally weak.” The findings:

Claude Opus 4.6: In 50 password generation runs, only 30 unique passwords were produced. One specific sequence appeared 18 times — a 36% hit rate on a single password.
GPT-5.2: Nearly all generated passwords started with the letter “v.”
Gemini 3 Flash: Consistently started with “K” or “k.”

This is a direct consequence of the same bias we’ve been discussing. Ask an LLM to “generate a secure random password,” and it will produce passwords that cluster around patterns overrepresented in training data — security blogs, password manager examples, demo credentials in tutorials. An attacker who knows these patterns can dramatically reduce their search space.

The risk compounds because coding agents (Claude Code, GitHub Copilot, Gemini CLI) have been found generating passwords in user code without being explicitly asked, and those passwords end up in public GitHub repositories.

A 2024 study from Mayo Clinic Proceedings (PMC) ran 1,000 GPT-4 simulations and concluded: “Publicly available chatbot LLMs demonstrate significant biases, which may negatively impact outcomes if used without appropriate precautions.” This was a clinical context — the stakes were decisions about patient care, not number games.

What This Tells Us About LLMs

The number experiment surfaces a fundamental architectural truth: LLMs are not simulators of randomness. They are simulators of human reasoning and human outputs.

This has practical implications that go beyond number-picking:

Don’t use LLMs for anything requiring genuine randomness. If you need a random number for a cryptographic nonce, a sampling algorithm, or a randomized experiment, use a proper CSPRNG (crypto/rand in Go, os.urandom() in Python, SecureRandom in Java). An LLM will give you a "humanly typical" number, not a uniformly distributed one.

Output distribution reflects training data distribution. When an LLM gives you an answer that seems oddly specific or strangely common, it’s often because that answer is overrepresented in the training corpus. The model is pattern-matching, not thinking.

Biases compound. The “7 effect” and the “7,200–7,500 cluster” are relatively harmless manifestations of training-data bias. The same mechanism is at work when models are biased about demographics, professions, sentiment, and factual claims. Understanding the number example makes it easier to reason about the more consequential ones.

Thinking mode helps, but doesn’t fix it. The original poster noted that models with extended reasoning were slightly less predictable — they engage in intermediate computation steps that partially disrupt direct pattern completion. But the underlying statistical substrate remains. A 2025 paper confirmed this: biases are “deeply embedded in training data” and persist even with architectural changes.

Can We Fix This?

RLHF and other alignment techniques can nudge model behavior, but they can’t fundamentally change the statistical substrate of a model’s outputs. Researchers tried obvious mitigations and found they don’t work:

Chain-of-Thought prompting: Insufficient — the model reasons about randomness using learned patterns, not actual entropy
Explicit “be truly random” instructions: Insufficient — the model produces what it predicts humans mean by “truly random.”
Reflection / self-correction: Insufficient — anchoring bias is stronger than self-correction in most tested models

The only approaches that actually work:

Explicit tool calls: Have the model call an external RNG via a function tool, then use that result. The model doesn’t generate the number — an actual entropy source does.
Hybrid architectures: Route randomness-requiring tasks to dedicated systems. LLMs for reasoning; CSPRNGs for entropy.

The honest answer is: if you need randomness, don’t ask an LLM. This isn’t a limitation that will be engineered away. It’s a consequence of what LLMs fundamentally are.

Summary

The Reddit number experiment is a neat, replicable demonstration of a deep truth about how LLMs work:

LLMs don’t have randomness — they have learned distributions over text, and those distributions reflect human biases
Humans cluster around 7,200–7,500 when picking “random” numbers in the 1–10,000 range; models learned this from training data
Models are worse than humans at randomness — the gap between LLM and true randomness is more than 2× the gap between human and true randomness (arXiv:2406.00092)
The bias has real security consequences — LLM-generated passwords are predictably weak, with some sequences appearing 36% of the time
Tool calls are the only reliable fix — routing randomness to external entropy sources rather than generating it with the model

The next time you ask an LLM to pick a number and it says 7,428, you’ll know exactly why. And if you ever find yourself betting your house against it — don’t.