# Is AILang harder for a frontier model than a familiar language?

Evidence corpus for the "Is AILang harder for a frontier model…" section of
`../format-findings.md`. The question: does AILang cost Claude *more* than a
language it knows from training (Rust)? Method: pass@1 over 6 samples of the
same task in AILang (two-example few-shot) vs Rust, single-shot, fresh clueless
agents, no tools, oracled afterward (`ail check`/`run` resp. `rustc` + stdout).

## task1-eval — ADT + match + recursion (all in the few-shot)

Evaluate `(A + B) * C` over a small `Expr` ADT. **AILang 6/6 = Rust 6/6**, no
gap — and all six AILang answers were byte-identical. When every construct is in
the few-shot, AILang is not harder for Claude. `ail/m.ail` runs to `20`.

## task2-countgt — count elements `> N` (needs a comparison, OUTSIDE the few-shot)

- `ail-noscan/m.ail` — the single-shot answer. The *logic is correct* (recurse,
  test, accumulate); it fails only on a guessed name: `> ` is not an AILang
  identifier. Representative of **0/6** in this condition. The Rust cell
  (`rust.rs`, idiomatic `filter().count()`) is **6/6**. So the single-shot gap
  is a *vocabulary* gap, not a reasoning gap — and the single-shot setup is
  unfair: in Rust Claude has its training plus the obvious ability to scan a
  crate, which AILang was denied.

- `ail-scan-loop/m.ail` — the **fair test**: same task, but Claude is given the
  prelude as a scanned library and then iterates on raw compiler output (how it
  actually works on an unfamiliar crate). It converges in two feedback rounds:
  `gt`+`(pat-ctor True)` → `(case true …)` → finally `match (compare h N) … GT`.
  Runs to `3`. The idiomatic path matches on the `Ordering` ADT that `compare`
  returns — never on a `Bool`.

## The finding

*No scan + terse errors* → Claude diverges. *Scan + diagnostic errors* → Claude
converges. Same model; the difference is the discovery affordances. The
"language is harder" gap dissolves under the workflow Claude really uses.

Two genuine AILang defects the thread exposed (filed as Gitea issues):

1. `ail builtins` lists no comparison operator — they live in the prelude, which
   `builtins` doesn't surface. The discovery tool is an incomplete API scan.
2. `match` on `Bool` passes `ail check` but is rejected by codegen
   (`match on non-ADT scrutinee (i1); MVP supports only ADTs`); with no `if`,
   branching on a Bool is a dead end. A check/codegen inconsistency.