ABSORB · Delivery Readiness

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.

01 — The Methodology Stack

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.

Before the agent runs

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.

During build

Semantic Intent — SSOT

Make intent the immutable source of truth at implementation. Code that carries its own meaning — auditable, AI-readable, drift-proof.

At the workflow layer

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.

At the decision moment

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.

Around the whole system

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.

Governance-Driven Design→Semantic Intent→Intent-as-Infrastructure→Synthesis Gate

02 — The Research

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.17114971

Governance-Driven Design (GDD)

10.5281/zenodo.20938777

The Synthesis Gate

10.5281/zenodo.20684282

Intent-as-Infrastructure

10.5281/zenodo.20681522

ABSORB — Delivery Readiness

10.5281/zenodo.23895787

See all writing →

Implementation

Source code for the original pattern, including the commit where the fix landed (7de571c), its validation tracking and governance enforcement.

View on GitHub →

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.


03 — Where It Started

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.

✗ The Anti-Pattern
// 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
✓ Semantic Intent
// 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 session
78%
Behavioral differentiation restored in production
0
Synchronization bugs post-implementation
95%
Reduction in debugging time

Figures 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.