"Goldberry is just another linter."

This document is the defense against that critique. It names the reasons the unified-contract idea has failed before and explains what goldberry does differently.

The web's contract surface is absurdly large. Here is the full stack, with the verification surface that exists at each layer:

Twelve layers. Each has tools.

None of the tools at any layer reference the invariants from any other layer. That is the actual disease.

Each layer exists because the previous layer's contract enforcement was insufficient. The layers are load-bearing:

• Linting exists because runtime errors are too late
• Coverage exists because tests lie about completeness
• Code splitting exists because bundles got too large
• Fingerprinting exists because CDNs cached stale code
• Browser detection exists because the platform is fragmented
• Lighthouse exists because perf is invisible to developers
• A11y tooling exists because lawsuits

Each layer is a refutation in goldberry's vocabulary. The web stack is a Lakatos research programme that never settled.

Unlike databases (which converged on a few patterns) or kernels (which converged on POSIX-ish), the web stayed in active refinement because the platform itself never stopped changing.

The web is the only software target that has to ship into a hostile, mutable, multi-vendor execution environment for an audience that includes everyone alive:

• You don't control the runtime
• The runtime updates without your consent
• The runtime is shipped by your competitors
• The runtime varies across platforms you don't control
• Accessibility law applies
• Performance budgets are device-tier-dependent
• The network is adversarial
• The user can install extensions that modify your DOM
• The user's grandparent might be using it

No other software target has this combination. Games have a fixed runtime. Mobile apps have a curated runtime. Servers control their runtime. Embedded controls their runtime.

Twelve layers of contract enforcement is not too many. It's barely enough.

SARIF (Static Analysis Results Interchange Format) lets ESLint + Stylelint + axe + TypeScript + Lighthouse emit findings into a common JSON shape that GitHub / Sonar / etc consume.

It's not formal verification but it's the closest thing to a unified contract surface that has shipped.

The goldberry-shaped extension: a SARIF-like schema where each finding cites the invariant (with :source: and :cluster: properties), not just a rule ID. Lint plugins, build assertions, runtime checkers all reference the same invariant catalog.

The catalog doesn't replace the tools. It gives them a shared vocabulary.

Bruce Hauman's Devcards (~2015) proves corpus-as-development- environment works. The key insight:

A component is incompletely specified by its source code. Its full specification is the cartesian product of (component x props x state x context). Render that product as cards, and the contract becomes inspectable, sharable, version-controlled.

Cards ARE the test cases ARE the documentation ARE the demo ARE the regression suite. Same artifact, four uses.

The ClojureScript/Devcards stack achieves this but requires the discipline to be designed in from day one. You can't retrofit Devcards onto a React codebase.

This is the same asymmetry as FoundationDB vs Antithesis. FDB built deterministic from day one. Antithesis added it via hypervisor for arbitrary dockerized software.

Goldberry's move: extract the invariants the CLJS stack enforces by construction, catalog them, let other paradigms verify against the catalog post-hoc.

People hate the web because the contract surface is so large that no individual engineer can hold it in their head, and the tooling pretends each layer is independent when in practice they pathologically interact.

The fix is not "fewer tools" - every tool is doing real work.

The fix is naming the invariants such that the interactions become visible. That's goldberry's bet.

The bet: by building a Lakatos-refined corpus of defects with falsifiable invariants, cross-referenced across implementations and eras, goldberry captures what 1990s formal methods got right (the abstractions) without the adoption barriers that killed them.

• Not the perfect frontend testing framework
• Not a best-practices guide
• Not a React tutorial
• Not a religion
• Not yet another linter

A catalog of refuted conjectures hardened into invariants, with provenance, paradigm-cross-referenced, ready to feed a DST harness.

The thing it competes with is institutional memory in senior engineers' heads. The thing it cannot replace is judgment about which entries matter most for which application.

Corpus-as-rendered-UI: a future state where the goldberry corpus itself ships as live, navigable cards. Each DEFECT-NNNN renders as a card showing the broken version, the fixed version, and the assertion that distinguishes them.

Hauman's idea is the right ancestor. That's where this goes.