RECALL: What COBOL's Failures Teach an AI-First Compiler

What COBOL Got Wrong — and Why It Matters Now

COBOL is 66 years old and still processes an estimated $3 trillion in daily commerce. It outlived every platform prediction made about it. That longevity is usually attributed to inertia — too much legacy code to replace. But inertia doesn't explain why the code still works. Something in the language's design made it durable.

The same discipline produced four notorious failure modes. Not bugs in individual programs — structural weaknesses in how the language handled ambiguity:

The dot. In COBOL, a period terminated entire logical blocks, not just statements. A misplaced dot silently restructured program logic. No error, no warning — wrong behaviour, potentially for years.

Column sensitivity. Code had to appear in specific column ranges inherited from punch cards. Column 7 for comments. Columns 8–11 for division headers. The physical position of a character on a line had semantic meaning, invisible to the eye and enforced by the compiler without explanation.

Copybook proliferation. Shared field definitions were copied between programs via COPY statements. Over decades, thousands of copybooks accumulated across systems, versions diverged, and nobody knew which was authoritative. Change one copybook — everything that copied it broke, and finding everything was manual archaeology.

Implicit behaviour everywhere. Move a value too large into a field — it truncated silently. Reference an uninitialised field — it used whatever was in memory. The language was designed to do something reasonable rather than error. Programs ran. They produced wrong output. Quietly. Sometimes for years.

Four failure modes. One root cause. The language trusted the programmer to know things the compiler could have enforced.

RECALL Inherits the Discipline — and the Lesson

RECALL was designed as a COBOL-inspired publishing language for the web. The divisions, the PIC types, the dot terminator, the DATA before PROCEDURE separation — all inherited deliberately. The thesis: COBOL's discipline of encoding intent precisely at the language level is the right model for a publishing language. The syntax is the statement, not the aesthetic.

Which means RECALL also inherited the obligation to learn from COBOL's failures. Each of the four failure modes maps directly to a design decision:

The dot is a single-line terminator only. RECALL statements are one line by design — a misplaced period cannot collapse nested scope because there is no nested scope to collapse. The structural danger doesn't exist.

Column sensitivity is fully resolved. RECALL is indent-insensitive. No Area A, no Area B, no positional rules. A DISPLAY statement works anywhere on the line.

The copybook problem is acknowledged and deferred. RECALL's COPY clause is on the roadmap with strict resolution rules — one authoritative source, circular dependency detection, duplicate field errors. The lesson is documented before the feature ships.

Implicit behaviour is where RECALL departs most sharply from COBOL — and where the AI-first design principle becomes visible.

The valueSet Distinction

In RECALL v0.8.7, the compiler learned to distinguish two states that look identical at runtime:

01 PAGE-SUBTITLE PIC X VALUE "".   ← explicit empty — intentional
01 PAGE-SUBTITLE PIC X.           ← no VALUE clause — undeclared

Both render empty in the compiled HTML. A human programmer reading the output cannot tell them apart. But they mean completely different things — and an AI compositor reading the DATA DIVISION needs to know which is which.

VALUE "" means: this field is intentionally empty. Do not fill it. The author made a decision.

No VALUE clause means: this field was declared but never given a value. It is ambiguous. Should the AI compositor generate content for it? Leave it empty? The language hasn't said.

COBOL would have silently accepted both. The program would run. The AI compositor would receive no signal about which case it was in — and would have to guess.

RECALL v0.8.7 adds a valueSet flag to every field in the parser's symbol table. When a field is referenced in PROCEDURE DIVISION but has no VALUE clause, the compiler emits RCL-W06:

WARNING [RCL-W06] uninitialised-field — program.rcl:8:4
  01 PAGE-SUBTITLE PIC X.
     ^^^^^^^^^^^^
  Field referenced in PROCEDURE DIVISION has no VALUE clause
  Hint: add VALUE "..." or VALUE "" to declare intent explicitly

This is not a convenience warning for human programmers. Human programmers already know whether they intended to leave a field empty. This warning exists for the AI compositor — so that every field it encounters in the DATA DIVISION has a declared state, not an ambiguous one.

That distinction — two states identical at runtime, semantically distinct in the compiler's symbol table — is the clearest single expression of AI-first language design.

Why Human Languages Fail AI Compositors

Most programming languages are designed for human programmers who fill gaps with implicit knowledge. They know the codebase. They remember what a field is for. They read the surrounding context and infer intent. They tolerate ambiguity because they can resolve it.

An AI compositor has none of this. It reads the schema, the DATA DIVISION, the COMMENT clauses — and operates strictly on what is formally declared. Ambiguity is not resolved by context. It is inherited. And when it is propagated into generated source at scale, it compounds silently.

This is why COBOL's four failure modes matter more in an AI-first context than they did in a human-only one. A human programmer who encounters a missing terminator notices it. An AI compositor that generates a missing terminator gets no feedback signal — it never learns the output was malformed, and it will do it again.

Every silent failure in the compiler is a hole in the AI compositor's contract. Every diagnostic that replaces a silent failure is a guarantee — the AI compositor will receive structured, stable feedback for anything it produces outside the language's rules. It can read that feedback. It can correct. It can learn from the signal.

RCL-023 (missing terminator) exists not because human programmers forget periods. It exists because AI compositors generating RECALL source need the compiler to catch what they miss — before any human sees the output.

The Contract

RECALL is approaching a design primitive that doesn't exist in any other publishing language: WITH INTENT.

PROCEDURE DIVISION.

   RENDER.
      DISPLAY HERO
         WITH INTENT "dramatic opening, single product, urgency without hype"
         WITH DATA PRODUCT-NAME, PRODUCT-TAGLINE, CTA-PRIMARY.

   STOP RUN.

The author declares what a block should feel like and what data it has to work with. An AI compositor — reading the live schema, the DATA DIVISION symbols, the COMMENT clauses — expands that into valid RECALL source. The compiler validates the output.

That contract is only as strong as the compiler's ability to catch everything it can catch. A compiler that accepts malformed output silently cannot be the validation layer. A compiler that lets uninitialised fields pass without signal cannot guarantee the compositor's data contract. A compiler that cannot distinguish intentional empty from undeclared empty gives the compositor nothing to reason from.

The hardening work that preceded WITH INTENT's implementation is not polish. It is the foundation the contract stands on.

RECALL Is What COBOL's Discipline Looks Like When the Runtime Is an AI Compositor

COBOL encoded business intent so precisely that mainframes could be trusted with it for 60 years. The divisions — IDENTIFICATION, ENVIRONMENT, DATA, PROCEDURE — were a formal separation of concerns that made programs readable, auditable, and maintainable across decades and across the people who maintained them.

That discipline was never about the mainframe. It was about the reader — the entity that needed to know what the program meant, not just what it did. In 1959 that reader was a business manager reviewing payroll logic. In 2026 that reader is an AI compositor expanding layout intent into valid source.

The lesson COBOL teaches is not that verbose syntax is good, or that fixed-width fields are correct, or that batch processing is the right model. The lesson is: encode intent precisely enough that the machine can be trusted with it. Make ambiguity a compiler error, not a runtime surprise. Separate concerns at the grammar level, not the convention level.

RECALL inherits that discipline and applies it to a new runtime — one that doesn't execute instructions but composes layouts. One that doesn't process records but expands intent. One that doesn't run in a data centre but reads a symbol table and produces source code.

The AI compositor is a new kind of runtime. RECALL is a language designed for it — not by adding AI features to an existing language, but by recognising that the 60-year-old discipline of making intent legible to machines is exactly what AI compositors need.

COBOL's discipline. A new runtime. The same sentence.