Following up on the Haskell benchmark, the OCaml benchmark, and the Python benchmark, I ran AoC 2025 Days 1–5 in ReScript — a typed functional language that compiles to JavaScript with a lean standard library, a distinct syntax, and very limited LLM training data.

This post covers three runs of the same benchmark, each adding a different intervention to see what helps models cope with an unfamiliar language:

1. Run 1 — no help at all. 3-minute timeout. 1 completer out of 10.
2. Run 2 — overflow warning + longer timeout. 2 completers.
3. Run 3 — a ReScript system prompt teaching syntax, stdlib, and types. 7 completers.

The contestants

Same 10 models across all three runs:

Run 2 — overflow warning + longer timeout

The first run was rough: 7 of 10 models ejected, claude-haiku-4-5 the sole completer, integer overflow the root cause of most failures. Two things changed for run 2:

1. Overflow warning baked into every prompt. ReScript's int type is 32 bits on the JavaScript runtime. Several puzzles produce answers in the tens of billions or hundreds of trillions — well beyond that ceiling. No warning was given in run 1. In run 2 every prompt includes an explicit note that large answers require float or BigInt.

2. Timeout increased from 3 to 5 minutes per attempt. ReScript project setup (initialising npm, configuring the build system, first compile) is non-trivial for models unfamiliar with the ecosystem. Three minutes left very little room for the actual solving.

The rules (Run 2)

Part 1 runs up to 3 attempts, each with a 5-minute window:

• Attempt 1: plain prompt + overflow warning
• Attempt 2 (on failure): "YOU MUST read llm-small.txt before starting"
• Attempt 3 (still failing): "YOU MUST read llm-full.txt before starting"
• Fail all three → ejected

The working directory contains two versions of the official ReScript llms.txt documentation: a 5,578-line condensed version and a 14,405-line full API reference. Models are not told about them on the first attempt.

Part 2 gets exactly one attempt. Any failure — wrong answer, timeout, or API error — means immediate ejection. No llms.txt hints.

API errors (quota limits, network failures) count as free retries and are not charged against the attempt limit.

Ejections (Run 2)

Two models completed all 10 parts: claude-opus-4-6 and kimi-coding/k2p5.

Did the overflow warning make a difference?

Yes — but with an asterisk.

In run 1, both claude-opus-4-6 and claude-sonnet-4-6 overflowed on Day 5 Part 2 and were ejected. In run 2, opus answered correctly and completed the benchmark. The warning worked exactly as intended for it.

alibaba/qwen3.5-plus tells a more complicated story. In run 1 it timed out on Day 2 Part 1 and was ejected. In run 2 it sailed through Days 2, 3, and 4 — even detecting and self-correcting an overflow mid-run on Day 2 Part 2. Then on Day 5 Part 2 it overflowed anyway and was ejected. The warning helped it reach six extra puzzle parts; it wasn't enough to protect it at the end.

The four models ejected on Day 1 Part 2 — haiku, sonnet, glm-5, minimax — gave algorithmically wrong answers rather than overflow answers. The overflow warning had nothing to do with their ejection. (In run 1, different models fell at Day 1 Part 2 — it's a tricky boundary-condition puzzle that catches different models in different sessions.)

Results (Run 2)

Day 1 Part 1 — Dial rotation counting

All 8 surviving models passed on attempt 1 — nobody needed the llms.txt reference this time. In run 1, three models only cleared Day 1 Part 1 by reading llm-full.txt on their third attempt. The extra two minutes made the difference.

mistral consumed most of its 200k context window without producing an answer — a different failure mode from run 1 (where it overflowed on every attempt), same outcome.

gpt-5.3-codex compiled a project, hit errors, then entered a loop of echoing each nudge back and responding "DONE" without doing any work.

Day 1 Part 2 — Counting zero-crossings during dial rotation

Day 1 Part 2 ejected four models in this run. k2p5 flipped from a wrong answer in run 1 to correct in run 2; the extra time appears to have made the difference. haiku, which was run 1's sole winner, went out here.

Day 2 Part 1 — Summing repeated-digit IDs in ranges

The puzzle answer is an 11-digit number — the first real overflow test.

qwen3.5-plus passed where it timed out in run 1 — the overflow warning appears to have steered it toward float arithmetic. Slow, but correct.

qwen3-coder-next spent over 40 minutes in a compile-debug loop and was ejected on cost grounds. Its total across Days 1–2: $11.36.

Day 2 Part 2 — Repeated-pattern IDs (any repeat count)

Another 11-digit answer.

qwen3.5-plus detected an overflowed intermediate result mid-run, switched to float arithmetic, and corrected itself — all within the same attempt.

Day 3 Part 1 — Maximizing 2-digit joltage from battery banks

Day 3 Part 2 — Maximizing 12-digit joltage from battery banks

The answer is a 15-digit number. All three passed.

Day 4 Part 1 — Grid neighbour counting (accessible paper rolls)

Day 4 Part 2 — Iterative grid removal simulation

Day 5 Part 1 — Range membership checking

Day 5 Part 2 — Counting total fresh IDs from overlapping ranges

The answer is a 15-digit number — the final overflow test.

opus answered in 16 seconds. In run 1, it overflowed the same puzzle. The overflow warning was the difference.

qwen3.5-plus fell to the pattern it had avoided on Days 2 and 3 — despite the warning and its earlier self-correction, it overflowed here and was ejected.

Full summary (Run 2) — all 10 models

Wall-clock seconds. ✗ = ejected at that part.

Token and cost breakdown for the completers and qwen3.5-plus. Costs are rough approximations based on published per-token pricing. I use subscription plans, so my actual spending is capped regardless.

† ejected on D5P2; D5P2 cost includes the final wrong attempt.

Run 1 vs Run 2

The overflow warning made a real difference for opus. The longer timeout saved k2p5. But six models out of ten still couldn't produce correct answers even with those helps. The bottleneck wasn't overflow — it was the language itself.

Run 3 — ReScript system prompt

Run 2 left an obvious question: if the problem is unfamiliarity with ReScript, what happens when you teach the model the language?

For run 3 I wrote a concise ReScript system prompt — roughly 150 lines covering project setup, syntax essentials, the type system (including the fact that int is 32-bit and bigint exists), common stdlib functions, and file I/O patterns.

How it was injected

The agent harness (pi) supports --append-system-prompt, which adds content to the default system prompt without replacing it. Each model was launched with:

pi --model <model> --thinking off \
   --append-system-prompt rescript-system-prompt.md \
   --session-dir . \
   '<puzzle prompt>'

This means every model saw pi's standard coding-agent instructions plus the ReScript reference below, before receiving the puzzle. No other hints — no overflow warning, no llms.txt documentation files.

The system prompt

## ReScript v12

ReScript is a typed functional language that compiles to JavaScript.
Think of it as **functional TypeScript** — if you can solve a problem in TypeScript,
you can solve it in ReScript using the same logic, just with different syntax.

### Project setup

**package.json**:
```json
{ "name": "my-project", "dependencies": { "rescript": "^12.1.0" } }
```

**rescript.json** (NOT bsconfig.json):
```json
{
  "name": "my-project",
  "sources": [{ "dir": "src", "subdirs": true }],
  "package-specs": [{ "module": "esmodule", "in-source": true }],
  "suffix": ".res.js"
}
```

Then: `npm install && npx rescript && node src/MyModule.res.js`

### Syntax essentials

```rescript
// Pipe operator (not |>)
[1, 2, 3]->Array.map(x => x * 2)->Array.filter(x => x > 2)

// Let bindings, no semicolons needed
let x = 42
let greet = (name) => "Hello " ++ name  // ++ for string concat

// Pattern matching
switch myValue {
| Some(x) => Console.log(x)
| None => Console.log("nothing")
}

// String operations
let lines = text->String.split("\n")
let trimmed = line->String.trim
let parts = line->String.split(",")
```

### Type system

```rescript
// Primitive types
let n: int = 42              // 32-bit signed integer
let f: float = 3.14          // 64-bit IEEE 754
let b: bigint = 99999999999n // arbitrary precision
let s: string = "hello"      // UTF-8 string
let c: char = 'a'            // single byte, no Unicode — prefer string
let ok: bool = true

// Float arithmetic uses distinct operators
let sum = 1.0 +. 2.5         // +.  -.  *.  /.
let converted = Int.toFloat(n)

// Modulo is a function call, not an infix operator
mod(7, 3)             // int modulo — NOT 7 mod 3, NOT 7 % 3
Float.mod(7.0, 3.0)  // float modulo

// Mutable values use ref
let counter = ref(0)
counter := counter.contents + 1  // := to set, .contents to read

// Records
type point = { x: float, y: float }
let p = { x: 1.0, y: 2.0 }

// Variants
type shape = Circle(float) | Rect(float, float)

// Option and Result
let found: option<int> = Some(42)
let parsed: result<int, string> = Ok(42)

// Arrays — main ordered data structure (like JS arrays)
let a = ["hello", "world"]
let first = a[0]              // Some("hello") — access returns option!
a[0] = "hey"                  // mutation
let b = [1, 2, ...a]          // spread

// List — immutable singly linked list
let l = list{1, 2, 3}
let l2 = list{0, ...l}        // prepend
```

### File I/O (Node.js bindings)

```rescript
@module("fs") external readFileSync: (string, string) => string = "readFileSync"

let content = readFileSync("input.txt", "utf8")
```

### Common stdlib

```rescript
// String
String.length: string => int
String.get: (string, int) => option<string>    // None if out of bounds
String.charAt: (string, int) => string        // "" if out of bounds
String.slice: (string, ~start: int, ~end: int=?) => string
String.split: (string, string) => array<string>
String.trim: string => string
String.includes: (string, string) => bool
String.startsWith: (string, string) => bool
String.replaceAll: (string, string, string) => string
String.make: 'a => string               // convert anything to string

// Array
Array.map: (array<'a>, 'a => 'b) => array<'b>
Array.filter: (array<'a>, 'a => bool) => array<'a>
Array.reduce: (array<'a>, 'b, ('b, 'a) => 'b) => 'b
Array.forEach: (array<'a>, 'a => unit) => unit
Array.length: array<'a> => int
Array.get: (array<'a>, int) => option<'a>

// Option — use getOrThrow, NOT getExn (deprecated)
Option.getOrThrow: (option<'a>, ~message: string=?) => 'a  // throws if None
Option.getOr: (option<'a>, 'a) => 'a           // default if None
Option.map: (option<'a>, 'a => 'b) => option<'b>
Option.flatMap: (option<'a>, 'a => option<'b>) => option<'b>
Option.isSome: option<'a> => bool
Option.isNone: option<'a> => bool
Option.forEach: (option<'a>, 'a => unit) => unit

// Result — use getOrThrow, NOT getExn (deprecated)
Result.getOrThrow: (result<'a, 'b>, ~message: string=?) => 'a  // throws if Error
Result.getOr: (result<'a, 'b>, 'a) => 'a
Result.map: (result<'a, 'c>, 'a => 'b) => result<'b, 'c>
Result.isOk: result<'a, 'b> => bool
Result.isError: result<'a, 'b> => bool

// Conversions
Int.fromString: (string, ~radix: int=?) => option<int>
Int.toString: (int, ~radix: int=?) => string
Int.toFloat: int => float
Float.fromString: string => option<float>
Float.toString: (float, ~radix: int=?) => string

// Output
Console.log: 'a => unit
Console.log2: ('a, 'b) => unit
```

The rules (Run 3)

Same retry logic as run 2 (up to 3 attempts on wrong answers), but:

• No overflow warning in the puzzle prompt — the system prompt documents int as 32-bit and bigint as arbitrary precision; models have to connect those dots themselves.
• No llms.txt escalation — models either know enough from the system prompt or they don't.
• 15-minute timeout per part (increased from the polling window, not per-attempt).

Ejections (Run 3)

Seven models completed all 10 parts.

Results (Run 3)

Day 1 Part 1 — Dial rotation counting

10/10 correct on first attempt. In run 2, two models were ejected here (devstral for filling its context window, codex for going brain-dead). The system prompt got them through.

Day 1 Part 2 — Counting zero-crossings during dial rotation

9/10 survived. In run 2, this puzzle ejected four models (sonnet, haiku, glm-5, minimax). With the system prompt, all four completed it. Only devstral couldn't solve it — it gave three different wrong answers across three attempts, each algorithmically different but each wrong.

Day 2 Part 1 — Summing repeated-digit IDs in ranges

The puzzle answer is an 11-digit number — the first real overflow test.

8/8 surviving models correct on first try. codex compiled a solution but it timed out on even the example input. After two dirty-stop retries it went brain-dead — echoing nudges and saying "DONE" without doing any work.

Day 2 Part 2 — Repeated-pattern IDs (any repeat count)

Another 11-digit answer.

All 8 correct. haiku was fastest at 18 seconds.

Day 3 Part 1 — Maximizing 2-digit joltage from battery banks

Day 3 Part 2 — Maximizing 12-digit joltage from battery banks

The answer is a 15-digit number.

All 8 correct. All handled the 15-digit answer — no overflow.

Day 4 Part 1 — Grid neighbour counting (accessible paper rolls)

Day 4 Part 2 — Iterative grid removal simulation

Day 5 Part 1 — Range membership checking

qwen3-coder-next read the real input file, dumped it into the context, started writing "I understand the problem now. The task is to: 1. Parse Ingredi—" and froze mid-sentence. No recovery.

Day 5 Part 2 — Counting total fresh IDs from overlapping ranges

The answer is a 15-digit number — the final overflow test.

Seven out of seven. In run 2, qwen3.5-plus overflowed this exact puzzle. With the system prompt documenting that int is 32-bit and bigint exists, it used bigint from the start and answered correctly. No explicit warning needed.

Full summary (Run 3) — all 10 models

Wall-clock seconds. ✗ = ejected at that part.

Token and cost breakdown for all models. Costs are rough approximations based on published per-token pricing. I use subscription plans, so my actual spending is capped regardless.

† ejected before completing all parts.

Across all three runs

Observations

Teaching the language was the biggest lever. The system prompt — 150 lines of syntax, types, and stdlib — took the completion rate from 2/10 to 7/10. The overflow warning in run 2 helped exactly one model (opus). The system prompt helped five more (sonnet, haiku, glm-5, minimax, qwen3.5-plus).

The overflow problem was a documentation problem. In run 2, qwen3.5-plus overflowed on Day 5 Part 2 despite an explicit overflow warning. In run 3, it used bigint from the start and answered correctly — because the system prompt documented int as 32-bit and bigint as arbitrary precision. Models don't need warnings; they need language specs.

claude-sonnet-4-6 went from run 2's Day 1 Part 2 casualty to run 3's fastest completer (464s). In run 2 it gave a wrong answer on the boundary-condition puzzle and was ejected. In run 3 it completed all 10 parts and beat opus on total time. The system prompt didn't just help with overflow — it helped models write correct algorithms in an unfamiliar language.

kimi-coding/k2p5 remains the value champion: $0.24 for all 10 parts. Down from $0.46 in run 2. The system prompt cut its token usage almost in half — fewer compile errors, fewer false starts.

Three models remain unreachable. devstral got further (past D1P1) but still couldn't solve D1P2. gpt-5.3-codex got further (past D1) but went brain-dead on D2P1. qwen3-coder-next got the furthest (8 parts) but froze mid-thought on D5P1. The system prompt can't fix models that go catatonic.

The llms.txt files were never needed. In run 2, no model proactively consulted them. In run 3, they weren't even offered. A concise system prompt covering the essentials was more effective than 14,000 lines of API reference sitting in the working directory.

Benchmarked on 2026-02-26 (run 2) and 2026-02-27 (run 3) using pi as the agent harness.

This post was written with AI assistance.