Coding got three times faster.
Delivery got 1.25× faster.Find where your changes wait.AI shortens the work, not the waiting — the queues, approvals and release windows around it. ABSORB splits every stage of delivery into work and waiting, names the constraint, and decides what can run with less human review — with a free assessment that runs entirely in your browser.
or go straight to the assessment ↗
The discipline before the agent runsGovernance-Driven Design — intent must be governed before anything is generated.A discipline for every layer
The Semantic Intent ecosystem covers the full AI-first delivery lifecycle — from formalizing intent before the machine runs to the architectural moment human judgment is required at execution, and whether the organization around it is ready for the speed.
This site organizes the work by idea. The same work, organized by what is being tested and where each line stands, is recorded at semanticintent.ai.
Governance-Driven Design
Formalize the assumption set. Run the ICR cycle. Surface what cannot be resolved without human judgment before a single artifact is produced.
Semantic Intent — SSOT
Make intent the immutable source of truth at implementation. Code that carries its own meaning — auditable, AI-readable, drift-proof.
Intent-as-Infrastructure
Bounded vocabulary declares what to reach. AI compiles how. Human judgment is the designed-in architectural endpoint — not a safety valve, not a fallback.
The Synthesis Gate
The architectural node where ambiguity enters and interpreted meaning comes out. One synthesis node is enough to make an entire chain agentic.
ABSORB — Delivery Readiness
The four disciplines above shape the machine. ABSORB asks whether the organization around it can absorb the speed: split every stage into work and waiting, name the constraint, and decide what can run with less human review — then check the prediction.
Published, open, citable
A growing series of formally documented methodologies — each openly licensed (CC BY 4.0 or MIT), DOI-minted, and backed by open-source implementation.
Paper Series
Semantic Intent as SSOT
10.5281/zenodo.17114971Governance-Driven Design (GDD)
10.5281/zenodo.20938777The Synthesis Gate
10.5281/zenodo.20684282Intent-as-Infrastructure
10.5281/zenodo.20681522ABSORB — Delivery Readiness
10.5281/zenodo.23895787Implementation
Source code for the original pattern, including the commit where the fix landed (7de571c), its validation tracking and governance enforcement.
Author: Michael Shatny · ORCID: 0009-0006-2011-3258 · Founding contributor to .netTiers (2005–2010), one of the earliest schema-driven code generation frameworks for .NET. The pattern — structured input, generated output, auditable artifacts — spans 28 years of the same architectural instinct applied across domains.
The premise: unify what code does with why it does it
The first paper, in 2025, started from one observation: code separates what it does (semantic anchoring) from why it does it (intent mapping), and AI-assisted generation widens that gap. The Semantic Intent pattern closes it with contracts that carry their own meaning, protected by immutable governance. Everything in the stack above grew from this premise.
// Technical flags driving business behavior
var isExecutive = analysisDepth === 'quick';
// HTTP method determining document type
async GetQuickReport(id) {
return service.generate(id, {
isExecutive: true // WRONG domain
});
}
// Result: identical 486,337-byte PDFs
// Debug time: 3+ weeks// Document semantics driving behavior
var intent = title.includes('executive');
// Observable properties → behavioral contract
var semantic = deriveFromRequest(request);
var report = service.generate(id,
protectIntent(semantic)
);
// Result: 9 pages vs 16 pages (78%)
// Debug time: one sessionFigures from the original report-generation case, as reported in the SSOT paper.
The pattern applies wherever a transformation layer can break the link between what code does and why: report generation (the original case), API contracts, configuration, and any codebase where AI generates or refactors behavior.