#!/usr/bin/env python3 """Build site2/index.html: the RNG-opening experiments.""" import json, sqlite3, shutil, html, os from collections import Counter BEATS = {"rock": "scissors", "paper": "rock", "scissors": "paper"} ICON = {"rock": "✊", "paper": "✋", "scissors": "✌️"} MAIN = "rps_big.sqlite" PROBES = [ ("rps_multiturn.sqlite", "No opening at all", 0, "Models free from round 1."), ("rps_noscissors.sqlite", "Round 1 may not be scissors", 0, "A rule in the system prompt, no RNG."), ("rps_norock.sqlite", "Round 1 may not be rock", 0, "Same, the other way round."), ("rps_seeded.sqlite", "4 random rounds narrated", 4, "RNG played the opening; the models were told about it."), ("rps_prescribed.sqlite", "5 random rounds played by the models", 5, "Each model was given its own RNG script to play out. The two scripts happened to overlap in 4 of 5 rounds."), ("rps_balanced.sqlite", "4 balanced rounds played by the models", 4, "Scripts constrained: no draws, wins split evenly."), ] def load(path): if not os.path.exists(path): return None db = sqlite3.connect(path) meta = dict(db.execute("SELECT key,value FROM meta")) cur = db.execute("SELECT round,haiku,sonnet,winner,haiku_raw,sonnet_raw,haiku_ms,sonnet_ms," "haiku_cost,sonnet_cost,haiku_input,sonnet_input FROM rounds ORDER BY round") cols = [c[0] for c in cur.description] return meta, [dict(zip(cols, r)) for r in cur.fetchall()] def score(rows): return (sum(1 for r in rows if r["winner"] == "haiku"), sum(1 for r in rows if r["winner"] == "sonnet"), sum(1 for r in rows if r["winner"] == "tie")) meta, rows = load(MAIN) P = int(meta.get("seed_rounds", "0") or 0) or int(json.loads(meta.get("prescribed_haiku", "[]")) and len(json.loads(meta["prescribed_haiku"])) or 0) plan = {p: json.loads(meta.get(f"prescribed_{p}", "[]")) for p in ("haiku", "sonnet")} P = len(plan["haiku"]) free = [r for r in rows if r["round"] > P] pre = [r for r in rows if r["round"] <= P] fh, fs, ft = score(free) ph, ps, pt = score(pre) # ---- move timeline ---- W, RH, PAD = 1180, 62, 46 n = len(rows) cw = (W - 2*PAD) / n def band(who, y, color): out = [] for i, r in enumerate(rows): x = PAD + i*cw won = r["winner"] == who out.append(f'') out.append(f'{r[who][0].upper()}') return "".join(out) sep = PAD + P*cw timeline = f""" rounds 1–{P}: scripted by the RNG rounds {P+1}–{n}: the models decide H S {band("haiku", 22, "#000")}{band("sonnet", 22+RH, "#000")} round 1 round {n} a filled box is a round that player won """ trs = [] for r in rows: scripted = r["round"] <= P bh = "font-bold" if r["winner"] == "haiku" else "" bs = "font-bold" if r["winner"] == "sonnet" else "" trs.append(f""" {r['round']}{' rng' if scripted else ''} {ICON[r['haiku']]} {r['haiku']} {ICON[r['sonnet']]} {r['sonnet']} {r['winner']} {r['haiku_ms']} / {r['sonnet_ms']} ms""") probe_rows = [] for path, name, np_, note in PROBES: got = load(path) if not got: continue m2, r2 = got pl = json.loads(m2.get("prescribed_haiku", "[]")) k = len(pl) or int(m2.get("seed_rounds", "0") or 0) fr = [r for r in r2 if r["round"] > k] a, b, t = score(fr) probe_rows.append(f""" {name}
{note}
{len(fr)}{a} {b}{t}""") hseq = "".join(r["haiku"][0] for r in free) sseq = "".join(r["sonnet"][0] for r in free) # ---- cross-provider section ---- def cross_block(): runs = [("rps_deepseek.sqlite", "DeepSeek reasoning, Haiku not", "DeepSeek was left with its chain of thought on while Haiku had thinking switched off. " "Not a fair fight, and the section below explains why it was run that way by accident."), ("rps_deepseek_nothink.sqlite", "Neither model reasoning", "The same match with reasoning suppressed on both sides, which is the only setting " "where the two are actually comparable.")] out = [] rows_html = [] for path, title, note in runs: if not os.path.exists(path): continue db = sqlite3.connect(path) rr = [dict(zip([c[0] for c in cur.description], r)) for cur in [db.execute("SELECT round,a_move,b_move,winner,scripted,a_ms,b_ms FROM rounds ORDER BY round")] for r in cur.fetchall()] fr = [r for r in rr if not r["scripted"]] hw = sum(1 for r in fr if r["winner"] == "haiku") dw = sum(1 for r in fr if r["winner"] == "deepseek") dr = sum(1 for r in fr if r["winner"] == "draw") hms = round(sum(r["a_ms"] for r in fr)/len(fr)) dms = round(sum(r["b_ms"] for r in fr)/len(fr)) hseq2 = "".join(r["a_move"][0] for r in fr) dseq2 = "".join(r["b_move"][0] for r in fr) rows_html.append(f''' {title}
{note}
{len(fr)}{hw} {dw}{dr} {hms} / {dms} ms''') out.append(f'''
{title}
Free rounds only, first letter of each move:
Haiku {hseq2}
DeepSeek {dseq2}
''') if not rows_html: return "" return f'''

Everything above is Claude against Claude. To check whether the lock-in is a quirk of one company's models, the same {30}-round format was run against DeepSeek V4 Flash, reached through the OpenCode Go gateway rather than the Claude Code CLI: a different vendor, a different API, a different transport for the conversation.

It behaves the same way. With reasoning switched off on both sides, {22} of the {24} free rounds were draws and the two move sequences were identical from the third round onward. The rock, paper, scissors cycle is not a Claude habit; it is what these models do when asked for a move with no deliberation, whoever built them.

With its reasoning left on, DeepSeek won twice as many rounds as Haiku — and took an average of 17.6 seconds per move against Haiku's 1.9, with one move taking 63 seconds. That result says something about thinking versus not thinking, not about which model is stronger.

{"".join(rows_html)}
MatchFree roundsHaiku DeepSeekDrawsAvg latency
{"".join(out)}

A note on how easily this was nearly got wrong: DeepSeek returns its chain of thought in a separate reasoning_content field, and those tokens are folded into completion_tokens with no separate count. Reading the usage numbers alone, the model looks like it answered in one word without thinking. The only reliable tell was the latency.

''' CROSS = cross_block() page = f""" Scripted openings · Haiku vs Sonnet

What happens if you hand a model a random opening and then let go?

Claude Haiku 4.5 and Claude Sonnet 5 play {n} rounds of rock paper scissors as a real conversation. A random number generator writes each player's first {P} moves; the models play those out, and then decide the remaining {n-P} for themselves.

The result in one line

Across the {len(free)} rounds the models actually chose, Sonnet won {fs}, Haiku won {fh}, with {ft} draws. Every earlier version of this experiment ended in a dead heat, most of them in an unbroken run of draws. The scripted opening is what made a difference visible.

The whole match

{timeline}

Why the opening is scripted

Left to themselves with reasoning switched off, both models do the same thing: they play rock, then paper, then scissors, then rock again, following the order the three options are listed in the prompt. Both sides do it at the same time, so the match becomes an unbroken chain of draws. An earlier {50}-round run ended 50 draws out of 50, with the two move sequences identical character for character.

Telling a model it may not open with rock does not help. It opens with paper instead, the next item on the list, and so does its opponent. The cycle just shifts by one.

What does help is starting the match somewhere that has no pattern to continue. The script here is built so the two players are pulled apart from the first move: no draws, and the {P} scripted rounds split evenly, {ph} wins each. By the time the models take over there is no clean cycle in the transcript to fall back into.

The script the models were given

Each player received its own move list in its system prompt and played it out itself, so those rounds sit in its transcript as its own turns rather than as something it was told about. Both models followed the script for all {P} rounds without a single deviation.

Haiku's script
{" · ".join(plan["haiku"])}
Sonnet's script
{" · ".join(plan["sonnet"])}
{html.escape(meta.get("system_prompt_haiku",""))}

What each model did once it was free

Sonnet's wins came from reading Haiku rather than from being unpredictable. Haiku settled into short repeating runs, and Sonnet took {fs} rounds off it, including two in a row at the end.

Free rounds only, first letter of each move:
Haiku {hseq}
Sonnet {sseq}

A model from a different company

{CROSS}

Every version tried

Only rounds the models chose are counted; scripted rounds are excluded. The last row is the match above.

{"".join(probe_rows)}
OpeningFree roundsHaiku SonnetDraws
{P} balanced rounds, {n} total
This page.
 {len(free)}{fh} {fs}{ft}

How the models were called

Both players are the same Claude Code binary with every default stripped away: no tools, no built-in system prompt, no settings files. Reasoning is switched off on both sides, so what you see is the model's immediate response. Each player holds one session for the whole match, so the conversation really is {n} exchanges long rather than one long recap.

MAX_THINKING_TOKENS=0 claude -p --model MODEL --effort low --tools "" \\
  --system-prompt SYSTEM --setting-sources "" --strict-mcp-config \\
  --disable-slash-commands --resume SESSION --output-format json

Each user turn reports only the round just played, in the form you: paper, opponent: scissors, result: you lost, followed by a request for the next move.

All {n} rounds

{"".join(trs)}
#HaikuSonnet WinnerLatency

Caveat worth keeping in mind: this is one match of {len(free)} free rounds. It is enough to show that a scripted opening breaks the deadlock, and not nearly enough to rank the two models at rock paper scissors.

Raw data: rps_big.sqlite · code: rps_multiturn.py, build_site2.py

""" os.makedirs("site2", exist_ok=True) open("site2/index.html", "w").write(page) for f in ("rps_big.sqlite", "rps_multiturn.py", "build_site2.py"): shutil.copy(f, "site2/") print(f"built: {n} rounds, {P} scripted, free score haiku {fh} sonnet {fs} ties {ft}")