Error Signal Fidelity: When the Compiler Speaks to the AI, Not the Human

The Assumption Hidden in Every Error Message

Every compiler error contains a hidden assumption: that a human will read it.

The message is prose because prose is how humans parse context quickly. The location is a file path and line number because a human will open the file, scroll to the line, read the surrounding code, and figure it out. The hint — if there is one — is written to be understood by someone who already knows the language and just made a small mistake.

These are the right design choices when the reader is human. They are not the only choices when the reader is an AI system generating the source.

A language model generating RECALL source does not open files. It does not scroll. It does not read surrounding code in the sense a human does — it processes a token sequence, and the quality of that processing depends on the structure of what it receives. Prose errors are signal. Structured errors are better signal. The difference compounds.

Two Errors for the Same Mistake

Consider an AI generating RECALL source that uses a slightly wrong element name. A human writing HTML or Markdown would get something like this:

error: unexpected identifier at line 42
  unexpected token 'HEADING-TITLE'
  expected: valid element name

What does this give an AI? A line number, a token it produced, and the information that it was wrong. No category. No suggestion. No indication of what the valid vocabulary looks like. The AI has to infer the fix from partial signal.

The same mistake in a RECALL source file, checked with recall check --format json, returns this:

{
  "errors": 1,
  "warnings": 0,
  "diagnostics": [
    {
      "code":     "RCL-003",
      "severity": "error",
      "category": "unknown-element",
      "file":     "page.rcl",
      "line":     42,
      "col":      11,
      "message":  "Unknown element",
      "why":      "HEADING-TITLE is not a registered element. Did you mean HEADING-1?",
      "hint":     "Run `recall schema` to see all valid elements.",
      "source":   "      DISPLAY HEADING-TITLE PAGE-TITLE.",
      "caret":    "              ^^^^^^^^^^^^^"
    }
  ]
}

Every field is machine-readable. The code is stable — RCL-003 is always RCL-003, not prose that varies by context. The category tells the AI what class of error this is. The hint points to the corrective action. The source line and caret give the AI the exact re-entry point. The why field already contains a "did you mean?" suggestion derived from the closed vocabulary.

The AI does not need to infer the fix. The diagnostic supplies it.

The Generation Loop

Error Signal Fidelity is about what happens inside this loop. Every step depends on the quality of what it receives from the previous step.

The loop is not a workflow added on top of RECALL. It is a design assumption baked into the diagnostic system from the start. The JSON output format, the stable codes, the per-code hints — all of it exists because this loop was the intended use case.

The Four Properties

Error Signal Fidelity in RECALL rests on four design decisions that were made together. Removing any one of them degrades the loop.

Five Error Codes in the Registry

The diagnostic registry contains 30+ error and warning codes. Each is defined with a stable code, description, example snippet, fix hint, and related codes. Click any entry to expand it.

Design, Not Tooling

The distinction matters. A tooling decision can be added later — you can wrap any compiler in a JSON formatter. A design decision cannot be retrofitted easily because it shapes what the system was built to do.

RECALL's diagnostic system was built knowing that the primary consumer of compiler output would be the AI compositor — not the human developer watching the terminal. That assumption is visible in the registry structure: every code carries a description, an example, a fix, and seeAlso links — not as documentation for humans, but as a machine-readable repair manual for the generation loop.

HTML has no error codes. Markdown has no error codes. JSX surfaces type errors from TypeScript, which were designed for human developers. RECALL has a diagnostic registry designed for the AI that generated the source in the first place.

That is the separation. Most notations treat errors as the end of a failed generation. RECALL treats errors as the input to the next one.

Related