Evidence, not claims

A convincing riso look needs real plate separation, dithering and mis-registration — and 'WASM is faster' is usually asserted, not measured.

Rust does the work in integer maths: a least-squares split into two ink plates, Floyd–Steinberg, Atkinson or blue-noise dithering, seeded grain, a whole-dot registration shift, and multiplied overprinting. A line-for-line JavaScript port races it on the visitor's own machine.

Modern JS engines are good at typed-array loops, so the speed margin is real but modest and varies by device; the page measures it live instead of quoting a number. The stronger case for Rust is bit-exact determinism.

Measure the speed claim on the user's machine, or don't make it.

A METAR (BKN025 27015KT 9999) describes the sky precisely, but to most people it reads like line noise.

A WebGL2 shader integrates atmospheric scattering and ray-marches each reported cloud layer as a volume; visibility becomes haze, wind moves the clouds, and the sun sits where it was at observation time. TypeScript parses the report and sets every shader input. On the live site a Cloudflare Pages Function proxies aviationweather.gov with a five-minute cache; bundled recorded reports are only a fallback, labelled RECORDED SAMPLE.

Coverage was only honest after calibration: seen from below, a thick layer covers more sky than any one slice of it. Cloud shapes are still procedural — a METAR gives amount and base, nothing else — and the page says which parts are data and which are style. On the deployed site the shared cache was seen working (a MISS, then a HIT); CPU time per request is still unmeasured.

Separate the data from the style on screen, then measure the data.

A summary of legal text sounds confident and gives you nothing to check it against — and a reader that needs a paid model can't be free for every visitor.

Pyodide (CPython compiled to WebAssembly) runs the project's own Python in a Web Worker, so a reading is free and the text never leaves the device: a clause segmenter, then 53 hand-written rules built from 136 bounded regular expressions, with negation and near-miss checks — no AI. Every matched quote goes through the verifier written for model output — an exact substring inside the clause it labels — and drops are counted on the page. A Claude reader exists in the repo but isn't deployed.

When a rule fires its label is usually right, but on unseen text it stays silent on about half the clauses that matter, and the page says so. The verifier proves a quote is in the text, not that the label is right. The first reading downloads a 13.6 MB Python runtime, stated before it starts.

Check every quote mechanically, whoever wrote the reading, and say what the rules can miss.

Erosion toys often look plausible while quietly creating or losing water and rock, and their rivers are traced from noisy water depth.

A virtual-pipe hydraulic-erosion model (Mei et al., 2007) with conservative sediment transport that books every source and sink, in Zig with @Vector SIMD and no allocation per step. Rivers come from a separate drainage survey — Priority-Flood pit filling, D8 routing, flow accumulation — that the physics never reads.

The deltas are modest (15–20 cells of new coast) and the delta test is fragile: r = 0.54 at 256², 0.39 on another survey, and nearby parameters swung it from about −0.5 to 0.8. The README says so.

Book every source and sink — a conservation test catches what a screenshot won't.

Cron implementations disagree about clock changes, and a job that is skipped, or runs twice, on the night the clocks change is easy to miss in review.

The engine is robfig/cron v3.0.1, the library Kubernetes uses to parse CronJob schedules, compiled with Go to WebAssembly, so the page shows that library's real behaviour rather than a re-implementation. For every day it compares the library's firings with a plain wall-clock reading and names each difference.

The tests found a quirk in Go itself: with the slim tz data built into WebAssembly, Time.ZoneBounds reports the period around 31 December of a leap year as ending before the time asked about. The engine corrects for it and a test pins it.

Model the library production actually runs, then test the model against it.

A REPL shows only the final value, so evaluation order, scope and closures stay invisible.

All ClojureScript: the real Clojure reader turns text into data, a small-step evaluator reduces one redex at a time in Clojure's order, and persistent data structures keep every state, so stepping back is just indexing. Anything outside the subset is refused by name before a step runs.

It is a subset, not Clojure: no macros, lazy sequences, destructuring or loop/recur, and map and filter are eager. About 65% of the 70 KiB gzipped bundle is cljs.core. Tested in Chrome only.

Refuse what you don't support, by name, instead of half-supporting it.

A puzzle's par is only fair if it is the true minimum — and a search that finds a good timetable doesn't prove there is no better one.

The rules, schedule and conflict detection are pure Elm functions of one immutable value, so undo and redo are two stacks. Exhaustive custom types (HeadOn | RearEnd | Crowded) kept the rules consistent while they changed. A Node mirror of the rules searches for each plate's par and proves it.

Plates IX–XIII have far too many timetables to try (plate IX alone about 6 × 10¹⁰), so their par is labelled heuristic and the stamp says so if you beat it. The proof runs on the mirror, not on the Elm code itself.

Prove what you can; label the rest as a heuristic.

Browser audio code must be deterministic, never allocate, and stay safe for the listener's ears, even when fed an extreme patch or a hostile link.

C11 with no libc, libm or heap: 8 voices × 6 operators, 8 algorithms, per-sample smoothing of every edit, then a compressor, a −3 dBFS peak limiter and a −1 dBFS hard ceiling. zig cc builds a 14.8 KB module with no imports that runs inside an AudioWorklet; JavaScript only draws the panel.

The voices were tuned by measuring rendered spectra and levels, not by ear; no human has listened yet. There is no oversampling, so BELL still aliases on very high notes. Tested in headless Chrome only, with the audio muted.

Put the safety limits in the engine, then attack them with hostile input.

A tangle can't be judged by eye: the same knot shows different crossings from different angles, and an eleven-crossing mess can be the unknot.

Pure TypeScript finds the crossings, builds the PD code and Alexander matrix, and takes the determinant by fraction-free Bareiss elimination over BigInt polynomials, so no floating point touches a coefficient. Relaxation provably never passes the rope through itself. three.js only draws.

The verdict says 'consistent with', never 'is': the Alexander polynomial can't tell a knot from its mirror image, and larger knots can share a small one's polynomial. Relaxing doesn't always untangle — the polynomial is what shows the eleven-crossing plate is the unknot.

Compute the exact part exactly, and word the verdict no stronger than the maths.

Stroke-order practice needs specific feedback — which stroke comes first, which way it runs — not a right-or-wrong at the end.

A Kotlin Multiplatform core with no browser APIs compares each stroke with KanjiVG's reference on position, shape (discrete Fréchet distance) and heading, forwards and backwards; a sealed-class state machine turns that into a verdict and a plain sentence. Kotlin/JS compiles it for the web; the same tests run again on the JVM.

Every accuracy figure comes from simulated strokes; accuracy on real learners' handwriting is unmeasured. Some first strokes are genuinely ambiguous, because nothing is written yet to align to.

Say where the numbers came from — synthetic strokes are not real handwriting.

Acceptance specs rot and drift into ambiguity, which is a leading indicator of rework.

Static checks over acceptance specs that reject criteria a test could not prove.

Concept stage — no results to report yet.

Ambiguity caught early is rework avoided later.

Long-context recall degrades near the window limit without the model signalling lower confidence.

Place adversarial needles across window-fill levels and chart the degradation curve.

Concept stage — no results to report yet.

Silent failure is the dangerous failure.

Tool-call schemas shift between model versions and break integrations quietly.

Pin the expected contract for each integration and alert on any drift.

Concept stage — no results to report yet.

Pin the contract, not the prompt.

Rollbacks are assumed to work until the first time they are actually needed.

Scheduled rollback drills in staging that measure and record recovery time.

Concept stage — no results to report yet.

An untested rollback is not a rollback.