Articles
Long-form thinking on semantic intent, AI-assisted development, and the patterns that preserve what code means.
The Schema Is the Editorial Policy
When AI is generating the content side of a RECALL brief, PIC X field declarations stop being a formatting detail and become a quality contract. Four rendering problems, one root cause — and why every fix pointed back to the schema, never the renderer.
Two Gaps: What Rune and Wake Are Actually Solving
They feel like different projects — a reactive binding protocol and a temporal memory server. But Rune and Wake address the same underlying problem on two different axes. One bridges the synchrony gap: the space between human intent and what AI can structurally access right now. The other bridges the temporal gap: the space between a decision made and a decision remembered. Together they describe what semantic continuity means in practice.
Rune Protocol: Discovered, Not Designed
Mere had four sigils before they had a name. @ ~ ! ? — read, sync, act, intent — were working in a reactive document format before anyone asked what they were formally. The protocol wasn't invented. It was extracted. What it turned out to be: a bounded-complete reactive binding grammar, a governance layer, and the syntax substrate the whole ecosystem was already running on.
Wake Intelligence: The Fourth Question
The first three layers ask why, how, and what. Layer 4 turns the question inward: how well am I actually predicting? Per-project weight tuning, cross-project causality, and semantic search — what shipped in v3.3.0 and why the hardest part was keeping three numbers well-behaved.
Wake Intelligence: The Three Questions Most Context Stores Never Ask
Most MCP context servers answer one question: what did we save? Wake Intelligence answers three: why was it created, how relevant is it right now, and what will be needed next. A 3-layer temporal intelligence brain for AI agents, built on Cloudflare Workers.
When the Methodology Becomes the Infrastructure
Methodologies are traditionally documents — frameworks that describe how to think but leave execution to interpretation. Methodology-as-Infrastructure proposes something different: that a sufficiently rigorous methodology can be compiled into a deterministic runtime layer that other systems build upon.
Strata: The Database Layer Needs Its Own Pipeline
Phoenix extracts intent from application code and rebuilds from zero. The database layer — stored procedures, SQL Agent jobs, linked servers, a decade of accumulated logic — doesn't follow the same rules. Introducing Strata: the sibling methodology for database archaeology.
The Grammar Ships: .sil Syntax Highlighting for VS Code
Syntax highlighting for .sil files started as a GitHub issue. Someone from the VS Code extension community found it within 24 hours. What the grammar reveals is more than aesthetic — each colour layer maps to a distinct semantic layer of the EMBER format.
The Invoice Is an App
An invoice is three computations: Σ(price × quantity), a tax rate applied to the subtotal, and a sum. Mere builds one in under 90 lines of declarative HTML — reactive computed chain, two screens, no JavaScript. The document and the app were always the same thing.
Mere: The File Is the App
A workbook format where the file contains everything — screens, state, behavior, theme, data. Open it and it runs. Send it and it travels. No server, no account, no build step. And why that matters more than it sounds.
CAL: A DSL Where the Cascade Is the Program
SWOT gives you four boxes. Porter gives you five forces. CAL gives you syntax. An introduction to the Cascade Analysis Language — a DSL that traces how failure and success propagate across six organizational dimensions, scores the result, and produces a deterministic decision.
From Draft to Artifact: The First Thing You Build with RECALL
Most people who find RECALL want to publish one thing — a case study, a report, a structured brief. That instinct is correct, and it leads somewhere larger. Three use cases, one progression: publish one thing, make it a template, watch the audit trail appear.
Error Signal Fidelity: When the Compiler Speaks to the AI, Not the Human
Most compiler errors are written for human eyes — prose messages, implicit assumptions, single-shot reads. When AI is generating the source, the reader is a language model. RECALL's diagnostic output was designed for that reader: stable codes, structured JSON, per-code hints, and exact location — all the inputs a generation loop needs to close.
Machine Legibility Dimensions: A Framework for Notations Designed for AI Readers
The Cognitive Dimensions of Notations framework evaluates languages from a human reader's perspective. As AI systems become primary authors and readers of formal notation, a different set of questions applies. Nine dimensions — tokenisation alignment, ambiguity surface, schema availability, error signal fidelity — and why one honest Neutral matters more than nine Positives.
RECALL: The Source That Knows Who Wrote It
Git blame tells you which commit touched a line. RECALL v1.1 goes further — authorship is a compile-time constraint. CREATED-BY accepts exactly three values: Human, AI compositor, or AI agent. The source doesn't just remember what was written. It remembers who.
RECALL-JCL: The Contract at Every Boundary
Distributed systems are not hard because the transport is hard. They are hard because the contract between systems is invisible. RECALL-JCL makes the contract the program — declared before execution, validated at compile time, sealed permanently in every artifact the pipeline produces.
WITH INTENT: The Clause That Writes the Source
RECALL compiles WITH INTENT to a placeholder. The clause that compiled to nothing produces source that compiles to something real — structured, field-typed, verified by the same compiler that validates everything else.
RECALL: The Institutional Memory Problem
An AI model re-enters your pipeline fresh on every run. No persistent mental model. No accumulated context. The Pipeline Manifest is the architectural answer — one machine-readable read that encodes everything the pipeline needs.
RECALL: What COBOL's Failures Teach an AI-First Compiler
COBOL had four failure modes — all rooted in trusting programmers with what compilers should enforce. Applying those lessons to RECALL reveals why the discipline is the proof of AI-first design, not just the positioning.
RECALL: Live Schema, Strict Mode, and the Idea That Emerged
A live schema the compiler queries itself. Structured diagnostic codes. Intent as a field-level type. Three features that solved immediate problems — and quietly built the infrastructure for something larger.
RECALL: What COBOL Would Have Built for the Web
It started as an aesthetic impulse — what if someone opened View Source and saw COBOL? Three days later it's a working compiler, a self-hosted documentation site, and the beginning of a semantic layer for AI orchestration.
EMBER: A Language Designed for the Third Reader
XML was designed for machines. Markdown was designed for humans. EMBER was designed for AI agents — and that distinction changes everything about what a language needs to be.
Semantic Intent Drift: The AI Coding Bug Your Tests Can't Catch
Your AI-assisted codebase has a class of bugs that's invisible to traditional testing. The code compiles. The tests pass. The behavior is wrong.