Blame for README.md

---
pretty_name: Cutaste — public benchmark (base-2026Q4.1-preview)
license: other
license_name: mixed
license_link: LICENSE.md
task_categories:
  - text-generation
language:
  - en
tags:
  - benchmark
  - evaluation
  - frontend
  - web-design
  - aesthetics
  - code-generation
  - coding-agents
size_categories:
  - n<1K
dataset_info:
  features:
    - name: task_id
      dtype: string
    - name: family_id
      dtype: string
    - name: category
      dtype: string
    - name: page_type
      dtype: string
    - name: brief
      dtype: string
    - name: measures
      dtype: string
    - name: requirement_points
      list:
        - name: id
          dtype: string
        - name: text
          dtype: string
    - name: viewports
      sequence: string
    - name: source
      dtype: string
    - name: source_id
      dtype: string
    - name: license
      dtype: string
  splits:
    - name: test
      num_bytes: 57996
      num_examples: 40
  download_size: 17982
  dataset_size: 57996
configs:
  - config_name: default
    data_files:
      - split: test
        path: data/test-*
---

# Cutaste — public benchmark (base-2026Q4.1-preview)

**What this is.** The benchmark half of Cutaste's public baseline: a fixed set of single-page web tasks for
coding agents, plus the rules they are scored by (render contract, check definitions, judge snapshot). **No
results are stored here.** The maintainer's results for this release (report, per-task results, judge
admission, the generated pages) are in the separate dataset
[`Validflow/cutaste-base-results`](https://huggingface.co/datasets/Validflow/cutaste-base-results) under the same tag `base-2026Q4.1-preview`.

- **Release:** `base-2026Q4.1-preview` (preview channel: scores are not promised to be comparable across versions)
- **Tasks:** 40, from [WebGen-Bench](https://huggingface.co/datasets/luzimu/WebGen-Bench) (test split, revision `c061fe8`, MIT); see *Relation to WebGen-Bench*
- **Configurations under test:** defined in `standard/configs/` (their results are in the results dataset)
- **Versions are git tags:** the tag `base-2026Q4.1-preview` pins this release (use `revision="base-2026Q4.1-preview"`); `main` always holds the newest release
- **Planned:** registration as a Hugging Face Benchmark (`eval.yaml`) once our evaluation framework can be listed

| Page category | Tasks |
|---|---|
| `app-ui` | 19 |
| `content-reading` | 9 |
| `e-commerce` | 6 |
| `marketing-landing` | 3 |
| `portfolio` | 3 |

## Folder structure

```text
README.md                         this card
LICENSE.md                        licences (mixed, see below)
data/test-00000-of-00001.parquet  the tasks as one table (config "default", split "test"; dataset viewer)
tasks/<family>/                   one folder per task, the files the cutaste CLI reads (see "Files of a task")
  task.md  measures.json  source.json  original.json  ui-instruct.json
standard/                         the scoring rules
  render-contract.json            render contract (browser, viewports, frozen clock, network off, font pack) and its hash
  checks.json                     floor checks: id, version, severity, what each one detects
  baseline-selftest.json          floor-check self-test on injected defects (recall / false-positive rate)
  requirement-checkers.json       requirement-point checkers and the point mapping rules
  judge-snapshot.json             frozen auto-judge rules: template, criteria, judge model, image policy, hash
  configs/<config>.json           configurations under test (harness, model, skills with pinned commits, fingerprint)
selection.json                    how the 40 tasks were picked (seed, candidate pool, list)
anchors/                          anchor tasks (README: none ship in this preview)
ledger/
  license-ledger.jsonl            one licence record per task (source, licence, evidence, packaging)
  sources.lock.json               pinned source files with sha256
  REBUILD.md                      how the maintainer rebuilds this release
LICENSES.md  NOTICE  CHANGELOG.md
prereg.json                       sha256 of every input file (tasks, rules, selection); `createdAt` says when it was frozen
manifest.json                     prereg hash + sha256 of the other files
SHA256SUMS                        sha256 of every file (sha256sum -c compatible)
assets/fonts/v1/                  font pack pinned by the render contract (fonts/, licenses/)
```

## Fields of `data/test-00000-of-00001.parquet` (one row per task)

| Field | Type | Meaning |
|---|---|---|
| `task_id` | string | Task card id, e.g. `card-webgen-000008-v1` (`task_id` in the results tables) |
| `family_id` | string | Task family id, e.g. `fam-webgen-000008` (folder name under `tasks/` here and `pages/<config>/` in the results) |
| `category` | string | Our page category: one of `marketing-landing`, `content-reading`, `portfolio`, `e-commerce`, `app-ui`, `data-dashboard` |
| `page_type` | string | WebGen-Bench `application_type`, verbatim |
| `brief` | string | The task text, verbatim WebGen-Bench `instruction` |
| `measures` | string | One sentence saying what the task measures (ours) |
| `requirement_points` | list of {`id`: string, `text`: string} | Points decidable on one static page; `text` = original UI test `task` + " Expected: " + `expected_result`, verbatim |
| `viewports` | list of string | Viewports the page is rendered and judged at (`desktop-1440x900`, `mobile-390x844@2x`) |
| `source` | string | Source benchmark and revision |
| `source_id` | string | Item id in the source benchmark (WebGen-Bench `id`) |
| `license` | string | Licence of the task text (from `ledger/license-ledger.jsonl`) |

## Files of a task (`tasks/<family>/`)

| File | Content |
|---|---|
| `task.md` | YAML front matter + body. Front matter: `id` (task card id), `familyId`, `scenario` (`frontend-aesthetic@1`), `locale`, `measures`, `requirementPoints` (list of `id`, `text`, `checker` — `fe.dom` for DOM/colour assertions, `fe.vlm` for screenshot checks — and `origin`, e.g. `original:ui_instruct-5` = index into the original test cases), `category`, `pageType`, `promptType`, `track` (`single-page`), `viewports`, `requiredSections`, `source` (`source.json`). Body: the brief, verbatim. |
| `measures.json` | What the task measures: `target` (`path`, `text`), `origin` (benchmark and original id), `requirementPoints` (ids), `difficulty`, `gap`, `hiddenDimension` (null for imported tasks), `generatedBy` (importer, seed). |
| `source.json` | Provenance: `kind` (`public`), `benchmark`, `revision`, `originalId`, `label` (`recognized`), `ledgerRef` (its line in the licence ledger), `original` (sha256 of the original record), `packaging` (`bundled`). |
| `original.json` | The original WebGen-Bench record, unchanged: `id`, `instruction`, `Category`, `application_type`, `ui_instruct` (every original UI test case). |
| `ui-instruct.json` | How the original UI test cases were used: `total`, `kept`, and `notApplicable` (`index`, `task`, `expectedResult`, `reasons`) for the cases that need multi-step interaction, a backend or persistence. |

## How to read it

**1. In the browser.** The dataset viewer shows the task table (config `default`, split `test`; the viewer works
on public datasets). *Files and versions* shows every file; pick the tag `base-2026Q4.1-preview` in the branch selector to
see exactly this release, and open `tasks/<family>/task.md` for one task.

**2. Python.**

```python
from datasets import load_dataset

tasks = load_dataset("Validflow/cutaste-base", split="test", revision="base-2026Q4.1-preview")   # 40 rows
print(tasks[0]["task_id"], tasks[0]["requirement_points"])
```

```bash
# the whole release as files (task folders, rules, prereg, checksums)
huggingface-cli download Validflow/cutaste-base --repo-type dataset --revision base-2026Q4.1-preview --exclude "assets/*" --local-dir taste-base
cd taste-base && sha256sum -c SHA256SUMS
```

While the dataset is private, log in first (`huggingface-cli login` or `HF_TOKEN`).

**3. Score your own agent with the `cutaste` CLI.**

```bash
npm i -g cutaste           # command: cutaste
cutaste base pull                # download and verify this benchmark (tasks + rules)
cutaste base run --config <your-config> --quick   # plan → confirm in your paired browser → runs your agent
cutaste base report              # downloads the maintainer's results from Validflow/cutaste-base-results, verifies them, shows them next to yours
```

`cutaste base run` re-renders the public configurations' pages on your machine and compares them with yours,
so differences between two machines' renderers do not enter the comparison.

## Same rules, comparable scores

A score is only comparable to another score produced under **the same rules**. The rules of this release:

| Rule | This release | Recorded in |
|---|---|---|
| Scenario | `frontend-aesthetic@1.0.0` | `standard/configs/*.json` (`scenario`), every evaluation (`scenario`, `scenarioVersion`) |
| Render contract | `sha256:ec7629d3c0a40e081293b5ff99c018f1ecc459a4f79206f1a223e0bdd9b0006b` | `standard/render-contract.json`; `contractHash` of every evaluation |
| Font pack | `taste-fontpack` v1, manifest `sha256:7c2f9985a470064a1d87e147fc6ebff7c928422d9375212657bb9a042f3f1a2c`, files at commit `5842d42078a0` | `assets/fonts/v1/` (part of the render contract) |
| Floor checks | `fe.no-output@1` (fatal), `fe.blank-page@1` (fatal), `fe.horizontal-scroll@1` (severe), `fe.text-overflow@2` (severe), `fe.overlap@2` (severe), `fe.contrast@2` (severe), `fe.contrast-aa@1` (minor), `fe.broken-image@1` (severe), `fe.required-sections@1` (severe), `fe.fabrication@1` (minor), `fe.console-errors@2` (severe), `fe.external-requests@1` (severe), `fe.font-fallback@1` (minor), `fe.small-text@2` (minor) | `standard/checks.json` |
| Requirement checkers | `fe.dom@2`, `fe.vlm@1`; point mapping `fe-points@2` | `standard/requirement-checkers.json` |
| Evaluation pipeline | `1` | evaluation cache key |
| Judge snapshot | `sha256:2cb205f0177ed401766f7174e4798b814aa50ff5997d5c9dc8f3ef77cf8cd69b` (J-2026Q4; template `fe.pointwise.public@1`, criteria hierarchy, typography, layout, contrast-harmony, consistency, brief-fit; judge codex-cli gpt-6.1-sol (medium)) | `standard/judge-snapshot.json` |
| Configurations under test | `codex-frontend-design` (gpt-6.1-sol), `codex-impeccable` (gpt-6.1-sol), `codex-plain` (gpt-6.1-sol) | `standard/configs/` (fingerprint = hash of the resolved config) |

- The render contract fixes the browser settings, viewports, frozen clock, network-off policy, full-page
  limit and the pinned font pack; its hash changes whenever any of them changes. Every evaluation in the
  results dataset records the contract hash it was rendered under (`contractHash`).
- The floor checks and requirement checkers are versioned one by one; an evaluation records the version of
  every check that ran.
- The judge snapshot (`judge/snapshot.json`) freezes the pairwise prompt template, the criteria, the judge
  model and reasoning effort and the image policy; its `hash` covers all of them. The aesthetic estimate in
  any report is only shown when the snapshot it was judged with has this hash and was admitted.
- `standard/render-contract.json` is frozen with the tasks: its sha256 is in `prereg.json` (frozen 2026-10-21T10:21:49.921Z).

Use a `cutaste` CLI that implements these rules: scenario `frontend-aesthetic@1.0.0` with the render contract and judge snapshot above — for this release, the `cutaste` CLI built from Cutaste commit `38060699e6dd`. Every local evaluation records the scenario
version, check versions and contract hash it used, and when your judge snapshot differs from this release's,
`cutaste base report` says so and shows no aesthetic numbers.

## Relation to WebGen-Bench

- **Selection.** 40 of the 101 WebGen-Bench test tasks, stratified by our page category,
  fixed seed. The seed, the candidate pool and the list are in `selection.json`; the pinned source file and its
  sha256 in `ledger/sources.lock.json`.
- **Briefs are verbatim:** 40/40 byte-identical to WebGen-Bench `instruction` at revision `c061fe8`.
- **Requirement points:** of the 264 original UI test cases for these tasks, 72 are kept — those
  decidable on one static page (e.g. colours, required text); their text is the original `task` +
  " Expected: " + `expected_result`, verbatim. The other 192 (multi-step interaction, backend,
  persistence) are marked not applicable.
- **Added fields:** `category` (mapped from `Category` / `application_type` to our 6 page categories),
  `page_type` (= `application_type`), `measures` (one sentence, ours), `viewports`.
- **Different task framing.** WebGen-Bench evaluates functional multi-page websites with a GUI agent. Cutaste
  asks for one self-contained static page (no network, interactions simulated client-side) and scores
  floor defects, requirement compliance and pairwise aesthetics. **Scores are not comparable to WebGen-Bench
  scores.**
- **Nothing is lost:** each task keeps the original record (`original.json`) and every original UI test
  case (`ui-instruct.json`).
- **What agents receive:** the brief plus the scenario's fixed page facts and sandbox rules. The sandbox rules,
  verbatim:

> # Sandbox rules (frontend-aesthetic, single page)
>
> You are building one static web page. Follow these rules exactly.
>
> 1. Write the page to `out/index.html`. Only files inside `out/` are collected.
> 2. You may add CSS, JavaScript and image files under `out/` (for example `out/styles.css`,
>    `out/app.js`, `out/images/hero.svg`) and reference them with relative paths.
> 3. The page must be fully self-contained and work offline:
>    - no network access while building or viewing;
>    - no external CDNs, script tags, stylesheets, web fonts or images from other hosts;
>    - no `http://` or `https://` URLs in `src`, `href`, `url()` or `@import`.
> 4. Fonts: use local font stacks (for example `system-ui, sans-serif`, `Georgia, serif`) or font
>    files you place under `out/`. Do not link to font services.
> 5. Images: draw them with inline SVG or CSS, or put files under `out/`. Every `<img>` needs an
>    `alt` text and explicit `width` and `height`.
> 6. There is no backend. Simulate interactive features (search, filters, forms, tabs, carts)
>    with front-end JavaScript and in-page data only.
> 7. The page is viewed at desktop 1440x900 and mobile 390x844 (device pixel ratio 2). It must
>    look intentional at both sizes with no horizontal scrolling.
> 8. Use only the content you are given. Do not invent facts, numbers, names, prices, quotes,
>    testimonials, ratings or logos that are not in the task.
> 9. Mark the root element of each required section with `data-section="<name>"`.
> 10. Do not use a build step or package manager; ship plain HTML, CSS and JavaScript.

## Licences

- Tasks (`data/`, `tasks/`): from WebGen-Bench, MIT License, © the WebGen-Bench authors (texts verbatim; attribution in `LICENSES.md`).
- `assets/fonts/v1/`: each font under its own licence (texts in `assets/fonts/v1/licenses/`): SIL Open Font License 1.1, Bitstream Vera Fonts licence.
- Everything else written by Cutaste (cards, rules, configurations, ledger, tables): CC BY 4.0.