#!/usr/bin/env python3 """Build site/index.html from one or more rps sqlite files. UnoCSS, white bg, black text, big type, rounded-lg.""" import json, sqlite3, shutil, html, os from collections import Counter RUNS = [ ("A", "rps.sqlite", "Run A · default thinking budget", "Only --effort low was set. Sonnet 5 did no thinking at all; Haiku 4.5 ignored the low setting and kept thinking for thousands of tokens per round, taking 20 to 45 seconds each time."), ("B", "rps_nothink.sqlite", "Run B · thinking disabled", "Same prompts, but MAX_THINKING_TOKENS=0 forced both models to answer immediately with no reasoning at all."), ("C", "rps_multiturn.sqlite", "Run C · real conversation, thinking disabled", "Thinking still disabled, but the match is now a genuine multi-turn conversation. Each player keeps one persistent session, so its own past moves sit in the transcript as its own assistant turns, and each user turn reports only the previous round: you: paper, opponent: scissors, result: you lost. Runs A and B instead re-narrated the whole history back to the model inside a single user message every round."), ] BEATS = {"rock": "scissors", "paper": "rock", "scissors": "paper"} COUNTER = {v: k for k, v in BEATS.items()} ICON = {"rock": "✊", "paper": "✋", "scissors": "✌️", "invalid": "❌"} 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_think,sonnet_think,haiku_attempts,sonnet_attempts," "sonnet_prompt FROM rounds ORDER BY round") cols = [c[0] for c in cur.description] rows = [dict(zip(cols, r)) for r in cur.fetchall()] return meta, rows def stats(rows, p, o): mv = [r[p] for r in rows]; ov = [r[o] for r in rows]; n = len(rows) best = cur = 0 for r in rows: cur = cur + 1 if r["winner"] == p else 0; best = max(best, cur) return dict(n=n, dist=Counter(mv), wins=sum(1 for r in rows if r["winner"] == p), losses=sum(1 for r in rows if r["winner"] == o), ties=sum(1 for r in rows if r["winner"] == "tie"), repeat=sum(1 for i in range(1, n) if mv[i] == mv[i-1]), beat_opp_prev=sum(1 for i in range(1, n) if mv[i] == COUNTER.get(ov[i-1])), cycle=sum(1 for i in range(1, n) if mv[i] == COUNTER.get(mv[i-1])), streak=best, avg_ms=round(sum(r[p+"_ms"] for r in rows)/max(n,1)), cost=round(sum(r[p+"_cost"] for r in rows), 4), think=sum(r[p+"_think"] for r in rows), retries=sum(r[p+"_attempts"]-1 for r in rows), invalid=sum(1 for r in rows if r[p] == "invalid")) def pct(a, b): return f"{100*a/b:.0f}%" if b else "-" def card(name, st, model): d = st["dist"] return f"""
{name}
{html.escape(model)}
{st['wins']} wins
Win / lose / tie{st['wins']} / {st['losses']} / {st['ties']}
Rock / paper / scissors{d.get('rock',0)} / {d.get('paper',0)} / {d.get('scissors',0)}
Repeated own last move{st['repeat']} ({pct(st['repeat'], st['n']-1)})
Countered opponent's last move{st['beat_opp_prev']} ({pct(st['beat_opp_prev'], st['n']-1)})
Cycled R→P→S{st['cycle']} ({pct(st['cycle'], st['n']-1)})
Longest win streak{st['streak']}
Average latency{st['avg_ms']} ms
Thinking tokens{st['think']}
Invalid / retries{st['invalid']} / {st['retries']}
Cost${st['cost']}
""" def chart(rows): n = len(rows); pts = []; d = 0 for r in rows: d += 1 if r["winner"] == "haiku" else -1 if r["winner"] == "sonnet" else 0 pts.append(d) W, H = 1000, 260 mx = max([abs(v) for v in pts] + [5]) X = lambda i: 50 + (W-70) * i / max(n-1, 1) Y = lambda v: H/2 - v * (H/2 - 20) / mx path = " ".join(f"{'M' if i==0 else 'L'}{X(i):.1f},{Y(v):.1f}" for i, v in enumerate(pts)) return f""" +{mx} 0 −{mx} round {n}""" def table(rows): trs = [] for r in rows: w = r["winner"] bh = "font-bold" if w == "haiku" else "text-gray-500" bs = "font-bold" if w == "sonnet" else "text-gray-500" if w == "tie": bh = bs = "" trs.append(f""" {r['round']} {ICON[r['haiku']]} {r['haiku']} {ICON[r['sonnet']]} {r['sonnet']} {w} {r['haiku_ms']} / {r['sonnet_ms']} ms {r['haiku_think']} / {r['sonnet_think']}""") return f"""
{''.join(trs)}
#HaikuSonnetWinner Latency H/SThinking H/S
""" sections, summary_rows, sys_prompt, sample_prompt = [], [], "", "" for key, path, title, note in RUNS: got = load(path) if not got: continue meta, rows = got if not rows: continue models = json.loads(meta.get("models", "{}")) sys_prompt = meta.get("system_prompt", sys_prompt) sample_prompt = rows[-1]["sonnet_prompt"] Hs, Ss = stats(rows, "haiku", "sonnet"), stats(rows, "sonnet", "haiku") lead = "Haiku" if Hs["wins"] > Ss["wins"] else "Sonnet" if Ss["wins"] > Hs["wins"] else "Nobody" summary_rows.append((title, len(rows), Hs["wins"], Ss["wins"], Hs["ties"], lead)) sections.append(f"""

{title} · {len(rows)} rounds

{note}

{card("Haiku 4.5", Hs, models.get("haiku",""))}{card("Sonnet 5", Ss, models.get("sonnet",""))}

Cumulative score. Above the dashed line means Haiku is ahead.

{chart(rows)}
All {len(rows)} rounds
{table(rows)}
""") srows = "".join(f"""{t} {n}{h} {s}{ti} {ld}""" for t, n, h, s, ti, ld in summary_rows) counts = {k: n for k, n, *_ in [(t.split(" ")[1], n) for t, n, *_ in summary_rows]} if summary_rows else {} a_n = summary_rows[0][1] if len(summary_rows) > 0 else 0 b_n = summary_rows[1][1] if len(summary_rows) > 1 else 0 page = f""" Haiku vs Sonnet · rock paper scissors

Does the bigger model play rock paper scissors better?

Claude Haiku 4.5 against Claude Sonnet 5. Before every round each player is shown the complete move history of the match, so any habit one model falls into is visible to the other.

Read the sample sizes first

Runs A and B were set up for 100 rounds each but the account hit its session limit partway through, and the API stopped returning moves. Run A kept {a_n} valid rounds, run B kept {b_n}. Every round after the cutoff was an infrastructure error rather than a played move, and those rows were deleted from the databases instead of being scored. Run C was a shorter match by design and ran to completion.

These are small samples from single matches. Nothing here settles whether one model is better at the game; the differences worth looking at are between the three formats, which turn out to be much larger than the differences between the two models.

{srows}
MatchRoundsHaiku SonnetTiesLeader

Setup

Both players are the same Claude Code binary invoked with every default stripped away: no tools, no built-in system prompt, no settings files, no session persistence. What reaches the model is only the system prompt below plus the round history, roughly 300 tokens at the start.

claude -p --model MODEL --effort low --tools "" \\
  --system-prompt SYSTEM --setting-sources "" --strict-mcp-config \\
  --disable-slash-commands --no-session-persistence --output-format json

System prompt, identical for both players:

{html.escape(sys_prompt)}

User message for the last round, as one player sees it:

{html.escape(sample_prompt)}
{''.join(sections)}

What actually happened

The question was whether the bigger model plays better. The honest answer from these three matches is that the prompt format mattered far more than the model.

In run A, where Haiku was still reasoning for thousands of tokens per round and Sonnet was answering instantly, Haiku came out ahead. In run B, with reasoning switched off on both sides, Sonnet came out ahead. Neither margin is large enough over 40 and 57 rounds to mean much on its own.

Run C is the result that is not close. Moving from a single narrated history to a real conversation, changing nothing else, produced fifty ties out of fifty. Both models locked onto rock, paper, scissors, rock, paper, scissors and neither deviated once for the entire match. The two move sequences are character-for-character identical.

The likely reason is where the history sits. In runs A and B a player's own past moves were narrated back to it as text written by someone else. In run C they are its own assistant turns, and continuing a pattern you can see yourself having authored is a much stronger pull than continuing one you were merely told about. With reasoning disabled there is nothing to interrupt that pull, so both players fell into the same cycle and stayed there.

Which means the experiment as designed cannot punish habit-forming models the way it was supposed to. Showing a model the full history is meant to let its opponent exploit any pattern. Instead, in the most conversational format, the history is what created the pattern, and both sides adopted the same one at the same time.

How to read the numbers

Raw data and code: rps.sqlite, rps_nothink.sqlite, rps.py, build_site.py

""" os.makedirs("site", exist_ok=True) open("site/index.html", "w").write(page) for f in ("rps.sqlite", "rps_nothink.sqlite", "rps.py", "build_site.py"): if os.path.exists(f): shutil.copy(f, "site/") for t, n, h, s, ti, ld in summary_rows: print(f"{t}: {n} rounds, haiku {h} sonnet {s} ties {ti}")